手机网站宽度自适应,wap网站制作教程,网上购物最便宜的网站,如何免费创建自己的小程序说说对Java线程的理解
下面是AI的回答 Java线程就是Java程序里面可以同时运行多个任务。Java提供了几种创建和管理线程的方式#xff0c;其中一种是继承Thread类#xff0c;另一种是实现Runnable接口或Callable接口。jdk5提供了线程池#xff0c;可以更方便地创建、启动和终…说说对Java线程的理解
下面是AI的回答 Java线程就是Java程序里面可以同时运行多个任务。Java提供了几种创建和管理线程的方式其中一种是继承Thread类另一种是实现Runnable接口或Callable接口。jdk5提供了线程池可以更方便地创建、启动和终止线程。在多线程编程中需要注意线程安全、死锁、线程阻塞等问题可以使用synchronized关键字保证线程安全使用Lock接口和Condition接口避免死锁问题使用Thread.sleep()方法避免线程阻塞问题。 一、了解基本概念——线程、进程、程序 程序(program)程序是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码。 进程(process)进程是程序的一次执行过程或是正在运行的一个程序。 是一个动态的过程有生命周期有它自身的产生、存在和消亡的过程。如运行中的QQ运行中的MP3播放器 一道程序可以被执行多次也就是由一道程序可以同时出现多个进程。 程序是静态的进程是动态的 进程作为系统资源分配的单位系统在运行时会为每个进程分配不同的内存区域 线程(thread)进程可进一步细化为线程是一个程序内部的一条执行路径。 在一个进程内可以同时执行多条线程。相当于一段时间内可以有三台车同时走三条路线 线程作为系统(CPU)调度和执行的单位。 若一个进程同一时间并行执行多个线程就是支持多线程的。如一个软件同时打开不同的界面。 一个进程中的多个线程共享相同的内存单元/内存地址空间。 系统分配进程的内存单元/地址空间被该进程内部的多个线程所共享。系统不会分配内存给线程
程序、进程、线程的关联
三者不是包含与被包含的关系进程是程序的运行时形态让程序动起来线程是程序的执行路线程序动起来了得知道该做什么可以两只手干活同时做不同是事情 提示程序、进程、线程是一个广泛的概念。比如操作系统也是一道程序、桌面应用也称一道程序。和软件的概念差不多。 理解用Java的角度 一个项目就是一个程序一个项目的运行就是一个进程一个项目进程可以有多条执行路线线程同时执行从内存的角度上看一个进程有一片内存区域线程没有线程用的是进程的多个线程共用进程的内存线程在进程的范围内活动线程可以理解为进程的活动轨迹进程可以理解为程序的活动一个Java应用程序java.exe进程其实至少有三个线程main()主线程gc()垃圾回收线程异常处理线程。当然如果发生异常会影响主线程。JVM本质上是一个程序。 开发体会 我们在编写Java程序中会必须考虑程序的线程而进程是由用户系统控制的我们开发者控制不了也无须考虑。
理解Java程序的进程
Java代码是程序但系统不能直接执行。不能在系统上直接运行JVM本质上也是程序每被系统调用执行一次创建一道进程在这道JVM进程内才可以执行Java代码(或叫java程序)。换句话说Java程序的进程本质上是JVM的进程。
JVM进程的内存分析 内存结构 在一个JVM进程中每个线程拥有独立的运行栈和程序计数器(pc)换句话说一个JVM进程有多份栈空间和程序计数器 好处线程切换的开销小 在一个JVM进程中多个线程从同一堆中分配对象换句话说一个JVM进程只有一份堆空间、一份方法区 好处可以访问相同的变量和对象。这就使得线程间通信更简便、高效。坏处但多个线程操作共享的系统资源可能就会带来安全的隐患。
二、Java中多线程的体现——Thread类 一个Java应用程序进程其实至少有三个线程main()主线程gc()垃圾回收线程异常处理线程。线程之间相互影响。 Java语言的JVM允许程序同时运行多个线程它通过java.lang.Thread类来体现。
java.lang.Thread是线程的抽象表示形式。jdk文档中Thread类中就有说明Thread是程序中的线程。
要想实现多线程必须在主线程中创建新的线程对象。Java语言使用Thread类及其子类的对象来表示线程。
Thread类的特性 每个线程都是通过某个特定Thread对象的run()方法来完成操作的经常把run()方法的主体称为线程体 特别的要通过该Thread对象的start()方法来启动这个线程而非直接调用run() 想要启用新的线程必须调用该线程对象的start方法。 start方法的作用 启动当前线程调用当前线程的run() 一个线程对象只能调用一次start()方法启动如果重复调用了则将抛出异常“IllegalThreadStateException”。 如果自己手动调用run()方法那么就只是普通方法没有启用新的线程。 run()方法由JVM调用什么时候调用执行的过程控制都由操作系统的CPU调度决定。
Thread类的构造器
Thread()创建新的Thread对象Thread(String threadname)创建线程并指定线程实例名Thread(Runnable target)指定创建线程的目标对象它实现了Runnable接口中的run方法Thread(Runnable target, String name)创建新的Thread对象 理解 一个线程在Java中体现为一个Thread类的对象线程的执行内容就是Thread类对象的run()的执行内容如何启动一个线程呢 4. 调用Thread对象的start() Thread类的常用方法即提供了线程相关的功能操作 void start() : 启动线程并执行对象的run()方法 void run() : 线程在被调度时执行的操作 String getName() : 返回线程的名称 void setName(String name):设置该线程名称 static Thread currentThread() : 返回当前线程。在Thread类及子类中就是this通常用于主线程和Runnable实现类 static void yield() 线程让步释放当前的CPU执行权 暂停当前正在执行的线程把执行机会让给优先级相同或更高的线程 join() 当某个程序执行流中调用其他线程的 join() 方法时调用线程将被阻塞直到 join() 方法加入的 join 线程执行完为止 低优先级的线程也可以获得执行 static void sleep(long millis) (指定时间:毫秒) 令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后重排队。睡眠期间被中断时抛出InterruptedException异常 stop() : 强制线程生命期结束不推荐使用。是过时的(Deprecated suspend()将线程挂起。不推荐使用容器造成死锁。是过时的(Deprecated resume()搭配suspend()使用也是过时的。不推荐使用。 boolean isAlive() 返回boolean判断线程是否还活着
三、创建线程的四种方式
官方API文档中说明了创建子线程的方式 JDK1.5之前创建新执行线程有两种方法 继承Thread类的方式实现Runnable接口的方式 JDK1.5新增了两者种创建新执行线程的方法 实现Callable接口使用线程池 思考 为什么不用直接创建Thread类的对象来创建新的线程呢 答线程的执行本质上就是Thread类对象里run()方法的执行直接创建Thread类虽然创建了新的线程但并不能让该线程执行想要的操作失去了意义。所以我们创建Thread类的对象的同时必须想办法重写该对象的run()将想执行的操作放进去官方给我们提供了几种方式。 方式一继承Thread类
步骤
定义子类继承Thread类。子类中重写Thread类中的run方法。将此线程执行的操作写在run()中创建Thread子类对象即创建了线程对象。调用线程对象start方法启动线程调用run方法。
举例输出100以内的偶数
//1.定义子类继承Thread类。
class MyThread extends Thread {//2.子类中重写Thread类中的run方法。Overridepublic void run() {for (int i 0; i 100; i) {System.out.print(i);}}
}
public class Test {public static void main(String[] args) {//3.创建Thread子类对象即创建了线程对象。//4.调用线程对象start方法启动线程调用run方法。//new MyThread().run();//行吗不行new MyThread().start();}
}//*********************简单化**************************
class Test {public static void main(String[] args) {//创建Thread的匿名子类对象new Thread() {Overridepublic void run() {for (int i 0; i 100; i) {System.out.print(i);}} }.start();}
}方式二实现Runnable
步骤 定义子类实现Runnable接口。 子类中重写Runnable接口中的run方法。 创建Runnable接口的子类的对象 通过将Runnable接口的子类对象作为实际参数传递给Thread类的含参构造器中来创建线程对象 调用Thread类的start方法开启线程调用Runnable子类接口的run方法。 //源码中Thread类的run()是这样的。其中target是Thread类的属性private Runnable target;
//结论使用含参构造器创建Thread对象传入Runnable对象时会将对象赋给targettarget不为空run()就会调用target也就是Runnable对象里的run()。
public void run() {if (target ! null) {target.run();}
}落地代码输出100以内的偶数
//1.定义子类实现Runnable接口。
class MyThread implements Runnable {//2.子类中重写Runnable接口中的run方法。Overridepublic void run() {for (int i 0; i 100; i) {System.out.print(i);}}
}
public class Test {public static void main(String[] args) {//3。创建Runnable接口的子类的对象Runnable r new MyThread();//4. 通过将Runnable接口的子类对象作为实际参数传递给Thread类的含参构造器中来创建线程对象//2. 调用Thread类的start方法开启线程调用Runnable子类接口的run方法。new Thread(r).start();}
}继承方式和实现方式的联系与区别 联系Thread类实现了Runnable接口。 //jdk8源码public class Thread implements Runnable {区别 继承Thread线程代码存放Thread子类run方法中。实现Runnable线程代码存在接口的子类的run方法。 实现Runnable方式的好处开发中推荐使用实现Runnable的方式 避免了单继承的局限性。 当一个类继承了Thread类就不能再继承其他的类了这是不方便的。 多个线程可以共享同一个接口实现类的对象非常适合多个相同线程来处理同一份资源。 举例说明 class Base extends Thread {public Base(Runnable r) {super(r);}public Base() {}Overridepublic void run() {System.out.println(这是Base);}
}
class Sub implements Runnable {Overridepublic void run() {System.out.println(这是Sub);}
}
class Test {public static void main(String[] args) {Runnable r new Sub();new Base(r).start();//这是Base}
}方式三实现Callable接口
与使用Runnable相比Callable功能更强大些
相比run()方法call()可以有返回值call()方法可以抛出异常Callable支持泛型call()支持泛型的返回值需要借助FutureTask类比如获取返回结果、创建Thread对象
Future接口
可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等操作。FutrueTask是Futrue接口的唯一的实现类FutureTask 同时实现了Runnable, Future接口。它既可以作为Runnable被线程执行又可以作为Future得到Callable的返回值
使用Callable接口创建新的线程
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;//1.创建一个实现Callable的实现类
class NumThread implements Callable {//2.重写Callable的Call方法将此线程需要执行的操作声明在call()中Overridepublic Object call() {//可以加throws//遍历一百以内偶数并返回所有偶数的和int sum 0;for (int i 1; i 100; i) {if (i % 2 0) {System.out.println(i);sum i;}}return sum;}}class Test {public static void main(String[] args) {//3.创建Callable接口实现类的对象NumThread numThread new NumThread();//4.将此Callable接口实现类的对象作为参数调用FutureTask的含参构造器创建FutureTask的对象。FutureTask futureTask new FutureTask(numThread);//5.将FutureTask对象作为参数传递到Thread类的构造器中创建Thread类的对象调用start()启动线程调用call()new Thread(futureTask).start();//new Thread(numThread).start();//不行。所以Callable接口需借助FutureTask对象来创建新线程。try {//6.可以获取call()的返回值。//get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值Object sum futureTask.get();System.out.println(sum);} catch (InterruptedException | ExecutionException e) {e.printStackTrace();}}
}方式四使用线程池 背景 经常创建和销毁、使用量特别大的资源比如并发情况下的线程对性能影响很大。 思路 提前创建好多个线程放入线程池中使用时直接获取使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。 好处 提高响应速度减少了创建新线程的时间降低资源消耗、提高资源的重用率重复利用线程池中线程不需要每次都创建便于线程的管理 Java中线程池由相关API体现
JDK 5.0起提供了线程池相关APIExecutorService 和 Executors
ExecutorService真正的线程池接口。常见子类ThreadPoolExecutor。包含一系列操作线程池的方法 常用方法如下 void execute(Runnable command) 执行任务/命令没有返回值一般用来执行RunnableT FutureT submit(CallableT task)执行任务有返回值一般用来执行Callablevoid shutdown() 关闭连接池 常见属性 corePoolSize核心池的大小maximumPoolSize最大线程数keepAliveTime线程没有任务时最多保持多长时间后会终止
Executors工具类、线程池的工厂类用于创建并返回不同类型的线程池。 常用方法如下 Executors.newCachedThreadPool()创建一个可根据需要创建新线程的线程池Executors.newFixedThreadPool(n); 创建一个可重用固定线程数的线程池Executors.newSingleThreadExecutor() 创建一个只有一个线程的线程池Executors.newScheduledThreadPool(n)创建一个线程池它可安排在给定延迟后运行命令或者定期地执行。
线程池的使用
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;class NumThread implements Runnable {Overridepublic void run() {for (int i 0; i 10; i) {System.out.println(Thread.currentThread().getName() : i);}}
}
class Num2Thread implements Callable {Overridepublic Object call() {for (int i 0; i 10; i) {System.out.println(Thread.currentThread().getName() : i);}return null;}
}public class Test {public static void main(String[] args) {//1.使用线程池工厂类提供指定线程数量的线程池ExecutorService service Executors.newFixedThreadPool(10);//2.调用新的线程执行指定的线程操作。需要提供实现Runnable/Callable接口实现类的对象service.execute(new NumThread());//适用于Runnableservice.submit(new Num2Thread());//适用于Callable//3.关闭线程池service.shutdown();}
}四、线程的调度策略
Java中线程的调度策略CPU分配给线程的策略 同优先级线程组成先进先出队列先到先服务使用时间片策略 时间片策略 对高优先级的线程使用优先调度的抢占式策略 抢占式策略 高优先级的线程抢占CPU的概率高
Java线程的优先级 线程的优先级等级 MAX_PRIORITY10MIN _PRIORITY1NORM_PRIORITY5 Thread类中涉及优先级的方法 getPriority() 返回线程优先值setPriority(int newPriority) 改变线程的优先级 说明 线程创建时继承父线程的优先级低优先级只是获得调度的概率低并非一定是在高优先级线程之后才被调用
五、守护线程与用户线程
Java中的线程分为两类一种是守护线程一种是用户线程。
说明
它们在几乎每个方面都是相同的唯一的区别是判断JVM何时离开。main主线程就是一个典型的用户线程。新建的Thread类对象默认是用户线程。守护线程是用来服务用户线程的通过在start()方法前调用thread.setDaemon(true)可以把一个用户线程变成一个守护线程Java垃圾回收就是一个典型的守护线程。若JVM中都是守护线程当前JVM将退出。 形象理解兔死狗烹鸟尽弓藏
六、线程的生命周期
JDK中用Thread.State类Thread的内部枚举类定义了线程的六种状态 NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING、TERMINATED
分析理解要想实现多线程必须在主线程中创建新的线程对象。Java语言使用Thread类及其子类的对象来表示线程在它的一个完整的生命周期中通常要经历如下的五种状态
新建 当一个Thread类或其子类的对象被声明并创建时新生的线程对象处于新建状态就绪 处于新建状态的线程被start()后将进入线程队列等待CPU时间片此时它已具备了运行的条件只是没分配到CPU资源运行 当就绪的线程被调度并获得CPU资源时,便进入运行状态 run()方法定义了线程的操作和功能阻塞 在某种特殊情况下被人为挂起或执行输入输出操作时让出 CPU 并临时中止自己的执行进入阻塞状态死亡 线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束
图解 备注
阻塞只是临时状态并不是最终状态。死亡是最终状态。
七、线程的同步机制
同步多线程在排队执行使用同一资源。异步多线程各干各的使用不同资源。
多线程的安全问题当多条语句在操作同一个线程共享数据时一个线程对多条语句只执行了一部分还没有执行完另一个线程参与进来执行。导致共享数据的错误。
对于多条操作共享数据的语句只能让一个线程都执行完在执行过程中即使该线程被阻塞其他线程都不可以参与执行。Java对于多线程的安全问题提供了专业的解决方式同步机制
1. synchronized
语法如下 同步代码块操作需要被同步的代码。 synchronized (同步监视器){ //同步监视器自己指定任意对象。// 需要被同步的代码即操作共享数据的代码
}例如 class W implements Runnable {private int ticket 100;public void run() {synchronized (this) {while (ticket 0) {System.out.println(currentThread().getName() 卖票 ticket--);} }}
}synchronized还可以放在方法声明中表示整个方法为同步方法。 public synchronized void show() { ... } //发现没有设置同步监视器的地方同步方法使用的是默认的同步监视器同步机制的使用说明总结注意两点同步监视器(锁) 、共享数据
synchronized的锁(同步监视器)是什么 任意对象都可以作为同步锁。所有对象都自动含有单一的锁监视器。 同步方法的锁是固定的一个线程类中的所有静态方法共用同一把锁类名.class所有非静态方法共用同一把锁this 静态方法的是当前类对象当前类名.class非静态方法的是当前对象this 同步代码块的锁自己指定开发中很多时候也指定为this或类名.class类对象。
锁的使用注意点必须确保使用同一个资源的多个线程共用一把锁这个非常重要否则就无法保证共享资源的安全。 理解当一个线程A要想进入同步代码中得先获得该同步代码的锁。只有一把锁时能保证一个线程在拥有锁并执行的时候另外的线程得不到锁直到该线程释放锁。若有多把锁时同样会造成多个线程同时执行语句造成线程安全问题。 class W extends Thread {private int ticket 100;public void run() {//synchronized(this) {//此时多个线程并没有共用一把锁因为每造一个线程就新建了一个对象synchronized(W.class) {//此时能保证多个线程用一把锁类对象是唯一的...}}
}
class Test {public static void main(String[] args) {new W().start();new W().start();}
}因为同步时被锁住的资源只能被一个线程使用缺点就是操作同步代码时只能有一个线程参与其他线程等待相当于是一个单线程的过程。所以在使用同步锁的时候需要尽量注意这些问题 同步的范围要锁住所有安全问题的代码尽量避免圈住没有安全问题的代码。 释放锁的情形有 当前线程的同步方法、同步代码块执行结束。当前线程在同步代码块、同步方法中遇到break、return终止了该代码块、该方法的继续执行。当前线程在同步代码块、同步方法中出现了未处理的Error或Exception导致异常结束。当前线程在同步代码块、同步方法中执行了线程对象的wait() 方法当前线程暂停并释放锁。 注意以下操作不会释放锁 线程执行同步代码块或同步方法时程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行线程执行同步代码块时其他线程调用了该线程的suspend()方法将该线程挂起该线程不会释放锁同步监视器。应尽量避免使用suspend()和resume()来控制线程 死锁问题 不同的线程分别占用对方需要的同步资源不放弃都在等待对方放弃自己需要的同步资源就形成了线程的死锁。出现死锁后不会出现异常不会出现提示只是所有的线程都处于阻塞状态无法继续。要避免死锁。死锁举例代码如下 public class DeadLockTest {public static void main(String[] args) {final StringBuffer s1 new StringBuffer();final StringBuffer s2 new StringBuffer();new Thread() {public void run() {synchronized (s1) {s2.append(A);//极大增加死锁概率// try {// Thread.sleep(1000);// } catch (Exception e) {// e.printStackTrace();// }synchronized (s2) {s2.append(B);System.out.print(s1);System.out.print(s2);} }}}.start();new Thread() {public void run() {synchronized (s2) {s2.append(C);//极大增加死锁概率// try {// Thread.sleep(1000);// } catch (Exception e) {// e.printStackTrace();// }synchronized (s1) {s1.append(D);System.out.print(s2);System.out.print(s1);} }}}.start();}
}
/**
运行结果
两种情况
1.ABABCD
2.死锁
*/2. Lock接口jdk5新增 从JDK 5.0开始Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁可以使用Lock对象充当。 Lock就没有同步监视器的概念了。Lock的实现类的对象充当锁。 java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。 锁提供了对共享资源的独占访问每次只能有一个线程对Lock对象加锁线程开始访问共享资源之前应先获得Lock对象。 ReentrantLock 类实现了 Lock 它拥有与 synchronized 相同的并发性和内存语义在实现线程安全的控制中比较常用的是ReentrantLock可以显式地加锁、释放锁
使用 class A{private final ReentrantLock lock new ReenTrantLock();public void m(){lock.lock();//保证线程安全的代码; unlock();}}//注意如果同步代码有异常要将unlock()写入finally语句块:lock.lock();try{//保证线程安全的代码; }finally{lock.unlock(); } 举例 class Window extends Thread {private static ticket 100;private static ReentrantLock lock new ReenTrantLock();//注意可以为非static吗在这里不可以Lock对象充当同步锁多线程共享统一资源要保证锁的唯一。public void run() {lock.lock();while (ticket 0) {System.out.println(currentThread().getName() 卖票 ticket--);}lock.unlock();}}synchronized与Lock的对比
Lock是显式锁手动开启和关闭锁别忘记关闭锁synchronized是隐式锁出了作用域自动释放Lock只有代码块锁synchronized有代码块锁和方法锁使用Lock锁JVM将花费较少的时间来调度线程性能更好。并且具有更好的扩展性提供更多的子类
开发体会
优先使用顺序性能从大到小 Lock — 同步代码块已经进入了方法体分配了相应资源— 同步方法在方法体之外
ReentrantLock的使用 构造器 ReentrantLock()ReentrantLock(Boolean fair) 如果传参为true例如线程A、B、C在锁前排队时如果让A进去了跑完之后A再回来排队会让B和C先跑。 …
八、wait()、notify()、notifyAll()
线程之间的通信表现为wait()与notify()和notifyAll() 的使用。
wait() 令当前线程挂起并放弃CPU、同步资源并等待使别的线程可访问并修改共享资源(当前线程会释放锁)而当前线程排队等候其他线程调用notify()或notifyAll()方法唤醒唤醒后该线程才会重新进入就绪状态等待CPU时间的分配。notify() 唤醒正在排队等待同步资源的线程中优先级最高者结束等待。只能唤醒一个wait()中的线程notifyAll () 唤醒正在排队等待资源的所有线程结束等待。唤醒所有wait()中的线程
使用说明 这三个方法只有在synchronized方法或synchronized代码块中才能使用也不能用在使用Lock对象的同步代码中否则会报java.lang.IllegalMonitorStateException异常。 需要注意的是如果一个线程调用了对象的wait()方法那么该线程必须先获得该对象的锁才能进入等待状态。如果没有获得该对象的锁那么会抛出IllegalMonitorStateException异常。此外如果当前线程被中断那么会抛出InterruptedException异常。就是该线程要获得该对象的锁才能执行wait()然后释放锁 wait()方法和notify()方法必须在同一个对象上调用这是因为它们是关联的。如果一个线程调用了对象的wait()方法那么其他线程必须调用同一对象的notify()方法或notifyAll()方法才能唤醒该线程。 这三个方法的调用者必须是synchronized方法或synchronized代码块中的同步监视器。否则报异常。 这三个方法是声明在java.lang.Object类中的。 因为这三个方法必须由锁对象调用而任意对象都可以作为synchronized的同步锁因此这三个方法只能在Object类中声明。
sleep()和wait()的异同 同一旦执行方法都可以使得当前的线程进入阻塞状态。 异 两个方法声明的位置不同Thread类中的声明sleep()Object类中声明wait()调用的要求不同sleep()可以在任何需要的场景下调用。wait()必须使用在synchronized方法或synchronized代码块中。关于是否释放同步监视器如果两个方法都使用在同步代码中sleep()不会释放同步监视器而wait()会释放同步监视器。
