本文详细介绍了Java中的线程概念，包括程序、进程和线程的基本区别，多线程的创建与使用，如继承Thread类和实现Runnable接口，以及线程的调度策略。还探讨了线程的生命周期，线程同步的必要性，如死锁问题和Lock锁的使用。此外，文章提到了JDK5.0引入的Callable接口和线程池的概念，以及它们相对于Runnable接口的优势。
Java 线程
文章目录
1. 基本概念：程序、进程、线程
-
程序（Program）是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。
-
进程（Process）是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。 ---- 生命周期
-
如：运行中的QQ，运行中的MP3播放器
在桌面按住 win + Shift + Esc 打开任务管理器，下面有一个“进程”选项，点击后，里面都是一些正在运行的进程。如图所示：
-
程序是静态的，进程是动态的
-
进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域
-
-
线程（Thread），进程可进一步细化为线程，是一个程序内部的一条执行路径。
比如：在IDEA里，main（）方法对应的就是一个线程，进入main（）方法，就是一条执行路径。
-
若一个进程同一时间并执行多个线程，就是支持多线程
例如：打开一个浏览器，里面可以开很多个网页，它们之间互不影响，这就说明这个浏览器就是支持多线程的，当我们打开一个网页时，系统会为该进程分配内存区域，当我们打开多个网页后，内存占比就会上升，也会占用CPU。如：
打开一个网页：
打开两个网页：
-
线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器（pc），线程切换的开销小。一个进程有自己一套的方法区和堆，多个线程共享进程中的方法区和堆。
-
一个进程中的多个线程共享相同的内存单元/内存地址空间 -> 它们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。
-
多线程
单核CPU和多核CPU的理解
- 单核CPU，其实是一种假的多线程，因为在一个时间单元内，也只能执行一个线程的任务，例如：虽然有多车道，但是收费站只有一个工作人员在收费，只有收了费才能通过，那么CPU好比收费人员。如果有某个人不想交钱，那么收费人员可以把他“挂起”（晾着他，等他想通了，准备好钱，再去收费）。但是因为CPU时间单元特别短，因此感觉不出来。
- 如果是多核的话，才能更好的发挥多线程的效率。（现在的服务器都是多核的）
- 一个Java应用程序java.exe，其实至少有三个线程：main() 主线程，gc() 垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。
并行与并发
- 并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。
- 并发：一个CPU（采用时间片）同时执行多个任务。比如：秒杀、多个人做同一件事。
多线程的优点
背景：以单核CPU为例，只使用单个线程先后完成多个任务（调用多个方法），肯定比用多个线程来完成用的时间更短，为何仍需多线程呢？
多线程程序的优点：
- 提高应用程序的响应。对图形化界面更有意义，可增强用户体验。
- 提高计算机系统CPU的利用率。
- 改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改。
何时需要用到多线程？
- 程序需要同时执行两个或多个任务。
- 程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。
- 需要一些后台运行的程序时。
2. 线程的创建与使用
在学习线程的创建之前，我们先看看下面的代码是否属于多线程？
public class Sample{
public void method1(String str){
System.out.println(str);
}
public void method2(String str){
method1(str);
}
public static void main(String[] args){
Sample s = new Sample();
s.method2("Hello!");
}
}
注意：上面的程序不是多线程。
怎么看是不是多线程？我们可以从main()方法下手，很明显上面的程序是先创建对象，然后调用method2()方法，执行method2()方法调用method1()方法，最后执行method1()方法，输出结果。从开始画一条线，能够连通全部，说明是一个线程（只针对于main()方法）。如下图所示：
线程的创建和启动
-
Java语言的JVM允许程序运行多个线程，它通过
java.lang.Thread类来体现。 -
Thread类的特性
-
每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常把run()方法的主体称为线程体。
-
通过该Thread对象的start()方法来启动这个线程，而非直接调用run()。
-
1. 多线程的创建
-
方式一：继承于Thread类
-
创建一个继承于Thread类的子类。
-
重写Thread类里的run()方法 —> 将此线程执行的操作声明在run()方法中。
-
创建Thread类的子类的对象。
-
通过此对象调用Thread类的start()方法。
start()方法作用：
- 启动当前线程。
- 调用当前线程的run()方法。
下面通过案例说明，例：遍历0~100之间的所有偶数？
// 1.创建一个继承Thread类的子类 class SonThead extends Thread{ // 2.重写Thread类的run()方法 public void run() { for (int i = 0; i < 100; i++) { if(i % 2 == 0){ System.out.println(i); } } } } public class MyThread { public static void main(String[] args) { // 3.创建Thread类的子类的对象 SonThead son = new SonThead(); // 4.通过创建的对象调用start()方法 son.start(); // 如下操作仍然是在main()主线程中执行的 System.out.println("Hello!"); } }运行结果为：
简单分析一下，当我们进入main()方法后，创建对象和调用对象的start()方法时，是在主线程中进行的，但是到了执行run()方法时（调用start()方法会自动调用run()方法），就分出了另一个线程（分线程，它是在主线程中生成的），然后执行最后一行代码
System.out.println("Hello!");是在主线程中进行的，这时就有两个线程同时在进行。（输出结果的快慢跟你所写代码和电脑的CPU有关，多执行几遍，结果可能不同）-
如果不去调用start()方法，直接调用run()方法（
son.run();），那它还是一个多线程吗？显然不是一个多线程了，程序会先执行run()方法，待方法执行完后，才会执行下面的语句。这样就不是同时进行了，当然不能算作多线程，它仅仅是一个main()主线程。（不管怎样执行，结果只有一种）
注意：
- 我们不能通过直接调用run()方法的方式启动线程。
- 如果再想启动一个线程，我们需要重新创建一个Thread的子类的对象，重新调用该对象的start()方法，不可以让已经start() 的线程去执行，否则会报
IllegalThreadStateException
-
练习：
创建两个分线程，其中一个线程遍历100以内的偶数，另一个线程遍历100以内的奇数。代码如下：
class SonThead1 extends Thread{
public void run() {
for (int i = 0; i < 100; i++) {
if(i % 2 == 0){
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
}
class SonThead2 extends Thread{
public void run() {
for (int i = 0; i < 100; i++) {
if(i % 2 != 0){
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
}
public class MyThread {
public static void main(String[] args) {
SonThead1 son1 = new SonThead1();
SonThead2 son2 = new SonThead2();
son1.start();
son2.start();
}
}
运行结果为：
从运行结果很容易看出，是两个线程同时执行的（Thread-0 和 Thread-1），而不是先输出偶数再输出奇数。这样就体现出了一个交互功能。
如果你想写的更简洁，并且只执行一次线程，那么可以采用创建Thread类的匿名子类的方式。代码如下：
public class MyThread {
public static void main(String[] args) {
new Thread(){
public void run() {
for (int i = 0; i < 100; i++) {
if(i % 2 != 0){
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
}.start();
new Thread(){
public void run() {
for (int i = 0; i < 100; i++) {
if(i % 2 == 0){
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
}.start();
}
}
运行结果跟上面的一种方式类似。如下：
运行结果与电脑的CPU有关，多执行几次，结果会有所差异。
-
方式二：实现Runnable接口
- 创建一个实现Runnable接口的类。
- 实现类去实现Runnable接口中的抽象方法：run()。
- 创建实现类的对象。
- 将此对象作为参数传递到Thread的构造器中，创建Thread类的对象。
- 通过Thread类的对象调用start()方法。
通过例子进行说明，如下：
// 1.创建一个实现Runnable接口的类 class DemoThread implements Runnable{ // 2.实现类去实现Runnable接口中的抽象方法：run() public void run(){ // 输出1~100之间的偶数 for(int i = 0;i < 100;i++){ if(i % 2 == 0){ System.out.println(Thread.currentThread().getName() + ":" + i); } } } } public class ThreadTest01{ public static void main(String[] args){ // 3.创建实现类的对象 DemoThread d1 = new DemoThread(); // 4.将此对象作为参数传递到Thread的构造器中，创建Thread类的对象 Thread t1 = new Thread(d1); // 5.通过Thread类的对象调用start()方法 t1.start(); } }这个t1就是创建的线程。这里我们调用的是Thread类 对象的start()方法，执行的是当前线程的run()方法，为什么可以执行DemoThread类中Runnable接口中的run()方法？
- 因为此时t1调用的start()方法调用的是Runnable类型的target的run()方法。不懂的可以去看看源码。
// 我们再启动一个线程，遍历1~100内的偶数，这时我们就没必要再去创建一个实现类的对象，如： public class ThreadTest01{ public static void main(String[] args){ DemoThread d1 = new DemoThread(); Thread t1 = new Thread(d1); t1.setName("线程1"); t1.start(); Thread t2 = new Thread(d1); t2.setName("线程2"); t2.start(); } }运行结果为：
2. Thread类常用的方法
-
void start()：启动线程，并执行对象的run()方法。
-
run()：线程在被调度时执行的操作。
-
String getName()：返回线程的名称。
-
void SetName(String name)：设置该线程名称。
-
static Thread currentThread()：静态方法，返回当前线程。在Thread子类中是this，通常用于主线程和Runnable实现类。
例如：
class ThreadSon1 extends Thread{ public void run(){ for (int i = 0; i < 100; i++) { if(i % 2 == 0){ System.out.println(Thread.currentThread().getName() + ":" + i); } } } } public class ThreadDemo { public static void main(String[] args){ ThreadSon1 t1 = new ThreadSon1(); t1.setName("线程一"); t1.start(); Thread.currentThread().setName("主线程"); for (int i = 0; i < 100; i++) { if(i % 2 != 0){ System.out.println(Thread.currentThread().getName() + ":" + i); } } } }运行结果为：
通过结果可以知晓，setName()方法可以设置线程名称，getName()可以获取线程名称。我们不知道main()线程名称时，可以用
Thread.currentThread()返回当前线程，然后再调用setName()和getName()方法设置和获取main()线程名称。 -
static void yield()：线程让步，释放当前CPU的执行权。
- 暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程。
- 若队列中没有同优先级的线程，忽略此方法。
实例如下：
class ThreadSon1 extends Thread{ public void run(){ for (int i = 0; i < 100; i++) { if(i % 2 == 0){ System.out.println(Thread.currentThread().getName() + ":" + i); } if (i % 10 == 0){ // 调用Thread类里的yield()方法 yield(); } } } }main()方法跟上面代码一样。
运行结果为：
当线程一，满足了条件调用yield()方法时，释放了当前CPU的执行权，但是后面紧接着又是线程一的数，说明线程一又分到了CPU的执行权。CPU处于待机状态下，分配到哪个线程是不确定的，谁都有可能，比如，我当前是线程一，释放了CPU执行权，CPU下一刻还是有可能再次分配到线程一，这是不确定的。
-
join()：当某个程序执行流中调用其他线程的join()方法时，调用线程将被阻塞，直到join()方法加入的join线程执行完为止。
- 低优先级的线程也可以获得执行。实例如下：
public class ThreadDemo { public static void main(String[] args){ ThreadSon1 t1 = new ThreadSon1(); // 给新生成的线程命名 t1.setName("线程一"); t1.start(); // 给主线程命名 Thread.currentThread().setName("主线程"); for (int i = 0; i < 100; i++) { if(i % 2 != 0){ System.out.println(Thread.currentThread().getName() + ":" + i); } if (i == 39){ try { // 调用Thread类的子类t1的join()方法 t1.join(); } catch (InterruptedException e) { throw new RuntimeException(e); } } } } }运行结果为：
当主线程中i的值为39时，调用了线程一的join()方法后，主线程会进入阻塞状态，直到线程一执行完后，才会结束阻塞状态。结束阻塞状态后，就看CPU如何分配资源了。分配到主线程，主线程才会继续执行任务。
-
static void sleep(long millitimes)：（指定时间：毫秒），让当前线程“睡眠”，在指定的millitimes毫秒时间内，当前线程是阻塞状态。
- 令当前活动线程在指定时间段内放弃对CPU的控制，使其他线程有机会被执行，时间到后重排队。
- 抛出InterruptedException异常。
实例如下：
class ThreadSon1 extends Thread{ // 重写Thread类里的run()方法 public void run(){ for (int i = 0; i < 100; i++) { if(i % 2 == 0){ try { sleep(500); } catch (InterruptedException e) { throw new RuntimeException(e); } System.out.println(Thread.currentThread().getName() + ":" + i); } } } }main()方法与上面的join()方法例子一样。
运行结果为：
这样我们很清晰的可以看到当主线程调用线程一的join方法后，主线程变为阻塞状态，不执行，直接执行线程一的任务，因为线程一调用了Thread类的sleep()方法，设置的时间为500ms（毫秒），所以结果会相隔0.5秒出现。
-
stop()：已过时。当执行此方法时，强制结束当前线程，不推荐使用。
-
boolean isAlive()：返回boolean，判断线程是否还存活。
例如：
public class ThreadDemo { public static void main(String[] args){ ThreadSon1 t1 = new ThreadSon1(); // 给新生成的线程命名 t1.setName("线程一"); t1.start(); // 给主线程命名 Thread.currentThread().setName("主线程"); for (int i = 0; i < 100; i++) { if(i % 2 != 0){ System.out.println(Thread.currentThread().getName() + ":" + i); } if (i == 39){ try { // 调用Thread类的子类t1的join()方法 t1.join(); } catch (InterruptedException e) { throw new RuntimeException(e); } } } System.out.println(t1.isAlive()); } }运行结果为：
很显然，当我们主线程i为39时，就会调用线程一的join()方法，这时就会等待线程一执行完，然后才会执行主线程，在主线程最后调用t1的isAlive()方法，线程一肯定已经结束了，所以结果为false。
3. 线程的调度
-
调度策略
-
时间片
-
抢占式：高优先级的线程抢占CPU
-
-
Java的调度方法
- 同优先级线程组成先进先出队列（先到先服务），使用时间片策略
- 对高优先级，使用优先调度的抢占式策略。
-
线程的优先级等级
- MAX_PRIORITY：10
- MIN_PRIORITY：1
- NORM_PRIORITY：5
-
涉及的方法
- getPriority()：返回线程优先级
- setPriority(int newPriority)：改变线程的优先级
实例如下：
class ThreadSon1 extends Thread{ // 重写Thread类里的run()方法 public void run(){ for (int i = 0; i < 100; i++) { if(i % 2 == 0){ System.out.println(getName() + ":" + getPriority() + ":" + i); } } } } public class ThreadDemo { public static void main(String[] args){ ThreadSon1 t1 = new ThreadSon1(); // 给新生成的线程命名 t1.setName("线程一"); t1.start(); // 给主线程命名 Thread.currentThread().setName("主线程"); for (int i = 0; i < 100; i++) { if(i % 2 != 0){ System.out.println(Thread.currentThread().getName() + ":" + Thread.currentThread().getPriority() + ":" + i); } } } }运行结果为：
-
说明
- 线程创建时继承父线程的优先级
- 低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用。
例如，在上面的代码中，我们给线程一设置优先级为最高
t1.setPriority(Thread.MAX_PRIORITY);，主线程的优先级设为最低Thread.currentThread().setPriority(Thread.MIN_PRIORITY);。运行结果为：
我们可以看到运行结果是不确定的，把线程一的优先级设为最高，主线程的优先级设为最低，不一定是线程一跑完了，才执行主线程，只能说线程一获得调度的概率大，主线程获得概率小，这不意味着高优先级的线程一定先执行完后，低优先级的线程才执行。
3. 线程的生命周期
- JDK中用Thread.State类定义了线程的几种状态：
要想实现多线程，必须在主线程中创建新的线程对象。Java语言使用Thread类及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下的五种状态：
- 新建：当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态。
- 就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源。
- 运行：当就绪的线程被调度并获得CPU资源时，便进入运行状态，**run()**方法定义了线程的操作和功能。
- 阻塞：在某种特殊情况下，被人为挂起或执行输入操作时，让出CPU并临时中止自己的执行，进入阻塞状态。
- 死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束。
线程的五种状态之间的关系如下图所示：
我们不仅要了解线程的五种状态，而且要记住它们之间是通过那些命令转换的。
4. 线程的同步
-
问题的提出：
- 多个线程执行的不确定性引起执行结果的不稳定。
- 多个线程对账本的共享，会造成操作的不完整性，会破坏数据。
-
举一个存在安全问题的例子，如下：
// 卖票100张，号码分别为1~100，由3个窗口售卖。 class SonThread extends Thread{ private static int ticket = 100; public void run(){ // 先判断是否有票 while(true){ if(ticket > 0){ System.out.println(Thread.currentThread().getName() + "：卖票，票号为：" + ticket); ticket--; }else{ break; } } } } public class ThreadDemo{ public static void main(String[] args){ SonThread s1 = new SonThread(); s1.setName("窗口一"); s1.start(); SonThread s2 = new SonThread(); s2.setName("窗口二"); s2.start(); SonThread s3 = new SonThread(); s3.setName("窗口三"); s3.start(); } }运行结果：
我们可以发现出现了重票，存在安全问题。还有一种情况就是出现错票问题，如下：
class SonThread extends Thread{ private static int ticket = 100; public void run(){ // 先判断是否有票 while(true){ if(ticket > 0){ // 这里加一条命令，让线程阻塞一下 try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "：卖票，票号为：" + ticket); ticket--; }else{ break; } } } } public class ThreadDemo{ public static void main(String[] args){ SonThread s1 = new SonThread(); s1.setName("窗口一"); s1.start(); SonThread s2 = new SonThread(); s2.setName("窗口二"); s2.start(); SonThread s3 = new SonThread(); s3.setName("窗口三"); s3.start(); } }运行结果：票号可能会出现 0 或者 -1 。
-
问题出现的原因：
当某个线程执行的过程（操作共享数据）中，尚未执行完时，其他线程参与进来，也执行了相应的程序（操作了共享数据）。
-
如何解决：
当一个线程在操作共享数据时，其他线程不能参与进来。直到线程a操作完时，其他线程才可以操作共享数据。这种情况即使线程a出现了阻塞，也不能改变。
-
在Java中，我们通过同步机制来解决线程的安全问题。
方式一：同步代码块
synchronized(同步监视器){ // 需要被同步的代码 }说明：
-
操作共享数据的代码，即为需要被同步的代码。（不能包含其他的代码，只能包含涵盖共享数据的代码）
-
共享数据：多个线程共同操作的变量。
-
同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。
要求：多个线程必须要共用同一把锁。
加上同步代码块。代码如下：
class SonThread implements Runnable{ private int ticket = 100; // 创建一个object对象 Object obj = new Object(); public void run(){ // 先判断是否有票 while(true){ synchronized (obj) { if (ticket > 0) { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "：卖票，票号为：" + ticket); ticket--; } else { break; } } } } }运行结果为：
加上同步代码块后，没有出现重票或者错票了。运行结果不同，跟电脑的性能有关。
我们上面说个
synchronized代码块后要有一个监视器（对象），并且必须唯一，这时我们可以用this来充当锁，因为this代表的是当前对象或当前方法，因为我们只创建了一个实现类的对象，所以this（当前对象）是唯一的。代码如下：
class SonThread implements Runnable{ private int ticket = 100; public void run(){ // 先判断是否有票 while(true){ synchronized (this) { if (ticket > 0) { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "：卖票，票号为：" + ticket); ticket--; } else { break; } } } } }运行结果一样，没有出现错票，重票。
注意：
-
在实现Runnable接口创建多线程的方式中，我们可以考虑使用
this充当同步监视器。不是所有情况下，具体问题具体分析。 -
在继承Thread类创建多线程的方式中，慎用
this充当同步监视器，可以考虑使用当前类充当同步监视器（继承类.class），这里的继承类.class是一个对象。Class cla = 继承类.class;，从定义上可以看出这个继承类.class就是一个对象。类.class只会加载一次，这就相当于锁是唯一的。
方式二：同步方法
如果操作共享数据的代码完整地声明在一个方法中，我们不妨将此方法声明为同步的。
private synchronized void method(){ // 需要被同步的代码（跟上面的一样） }- 在实现Runnable接口的方式创建多线程中，我们如何使用同步方法来解决线程安全问题。代码如下：
class SonThread implements Runnable{ private int ticket = 100; public void run(){ while(true){ show(); if (ticket == 0) { break; } } } private synchronized void show(){ if (ticket > 0) { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "：卖票，票号为：" + ticket); ticket--; } } } public class ThreadDemo{ public static void main(String[] args){ SonThread s = new SonThread(); Thread s1 = new Thread(s); Thread s2 = new Thread(s); Thread s3 = new Thread(s); s1.setName("窗口一"); s2.setName("窗口二"); s3.setName("窗口三"); s1.start(); s2.start(); s3.start(); } }运行结果为：
同步方法里也有同步监视器，默认为
this。- 在继承Thread类的方式创建多线程中，我们如何使用同步方法来解决线程安全问题。代码如下：
class SonThread extends Thread{ private static int ticket = 100; public void run(){ while(true){ show(); if (ticket == 0) { break; } } } // 这里要改成静态方法，这样锁才是唯一的 private static synchronized void show(){ if (ticket > 0) { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "：卖票，票号为：" + ticket); ticket--; } } public class ThreadDemo{ public static void main(String[] args){ SonThread s1 = new SonThread(); s1.setName("窗口一"); s1.start(); SonThread s2 = new SonThread(); s2.setName("窗口二"); s2.start(); SonThread s3 = new SonThread(); s3.setName("窗口三"); s3.start(); } }运行结果跟上面大致一样。
关于同步方法的总结：
-
同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。
-
非静态的同步方法，同步监视器是：this。
静态的同步方法，同步监视器是：当前类本身。
-
-
优点：同步的方式，解决了线程的安全问题。
缺点：效率低。操作同步代码块时，只能有一个线程参与，其他线程需等待，相当于是一个单线程的过程。
线程的死锁问题
-
死锁
-
理解：不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。
-
说明：出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续。
我们使用同步时，要避免死锁。
-
-
解决方法
- 专门的算法、原则
- 尽量减少同步资源的定义
- 尽量避免嵌套同步
-
下面举个关于死锁的例子
public class ThreadTest{ public static void main(String[] args){ // 创建StringBuffer类的对象 StringBuffer s1 = new StringBuffer(); StringBuffer s2 = new StringBuffer(); // 第一个线程，继承Thread类 new Thread(){ public void run(){ synchronized (s1){ s1.append("a"); s2.append("1"); // 为了提高出现死锁的概率，sleep()方法 try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (s2){ s1.append("b"); s2.append("2"); System.out.println(s1); System.out.println(s2); } } } }.start(); // 第二个线程，实现Runnable接口 new Thread(new Runnable(){ public void run(){ synchronized (s2){ s1.append("c"); s2.append("3"); synchronized (s1){ s1.append("d"); s2.append("4"); System.out.println(s1); System.out.println(s2); } } } }).start(); } }运行结果为：
由图可知，线程没有结束，出现了死锁问题。
Lock（锁）
-
从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。
-
java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。 -
ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。 -
如何用 Lock 解决线程安全问题。
方式三：Lock 锁
class SonThread implements Runnable{ private int ticket = 100; // 1.实例化一个ReentrantLock对象 private ReentrantLock lock = new ReentrantLock();// 可以带参数，不写默认fault public void run(){ while(true){ try{ // 2.调用锁定方法：lock() lock.lock(); if (ticket > 0) { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "：卖票，票号为：" + ticket); ticket--; } else { break; } }finally{ // 3.调用解锁方法：unlock() lock.unlock(); } } } } public class ThreadDemo{ public static void main(String[] args){ SonThread s = new SonThread(); Thread s1 = new Thread(s); Thread s2 = new Thread(s); Thread s3 = new Thread(s); s1.setName("窗口一"); s2.setName("窗口二"); s3.setName("窗口三"); s1.start(); s2.start(); s3.start(); } }运行结果为：
这种方式也可以解决线程的安全问题。
面试题
synchronized 与 Lock 有何异同？
-
相同点：二者都可以解决线程的安全问题。
-
不同点：
synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器。Lock需要手动的启动同步（lock()），同时结束同步也需要手动的实现（unlock()）。
建议：
-
优先使用顺序：高到低
Lock —— 同步代码块（已经进入了方法体，分配了相应资源）—— 同步方法（在方法体之外）
5. 线程的通信
线程的通信，就是线程和数据之间的联系，我们通过下面的例子来说明：
例：使用两个线程打印1-100。线程1、线程2交替打印。
// 实现Runnable接口创建线程
class SonThread implements Runnable{
private int number = 1;
//重写run()
public void run(){
while(true){
synchronized(this){
//唤醒线程
this.notify();
if(number <= 100){
try {
//阻塞但是不会释放锁
Thread.sleep(100);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println(Thread.currentThread().getName() + ":" + number);
number++;
try {
//使得调用如下wait()方法的线程进入阻塞状态，会释放锁
this.wait();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}else{
break;
}
}
}
}
}
public class CommunicationTest{
public static void main(String[] args){
SonThread s = new SonThread();
Thread t1 = new Thread(s);
Thread t2 = new Thread(s);
t1.setName("线程1");
t2.setName("线程2");
t1.start();
t2.start();
}
}
运行结果为：
上述代码中，涉及三个方法：
- wait()：一旦执行此方法，当前线程就会进入阻塞状态，并释放同步监视器。
- notify()：一旦执行此方法，就会唤醒被 wait 的一个线程。如果有多个线程被 wait，就唤醒优先级高的那个。
- notifyAll()：一旦执行此方法，就会唤醒所有被 wait 的线程。
说明：
- wait()、notify()、notifyAll() 三个方法必须使用在同步代码块或同步方法中。
- wait()、notify()、notifyAll() 三个方法的调用者必须是同步代码块或同步方法中的同步监视器。否则，会出现IllegalMonitorStateException异常。
- wait()、notify()、notifyAll() 三个方法是定义在
java.lang.Object类中。
面试题
sleep() 和 wait() 的异同？
- 相同点：一旦执行方法，都可以使得当前线程进入阻塞状态。
- 不同点：
- 两个方法声明的位置不同，Thread类中声明sleep()，Object类中声明wait()。
- 调用的要求不同，sleep() 可以在任何需要的场景下调用，wait() 必须使用在同步代码块或同步方法中。
- 关于是否释放同步监视器，如果两个方法都使用在同步代码块或同步方法中，sleep() 不会释放同步监视器，wait() 会释放同步监视器。
经典例题
生产者/消费者问题：
- 生产者（Productor）将产品交给店员（Clerk），而消费者（Customer）从店员处取走产品，店员一次只能 持有固定数量的产品（比如：20），如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。
- 这里可能出现两个问题：
- 生产者比消费者快时，消费者会漏掉一些数据没有取到。
- 消费者比生产者快时，消费者会取相同的数据。
下面用代码实现，如下：
//店员
class Clerk{
private int productor;
public synchronized void producerProductor(){
if(productor < 20){
productor++;
System.out.println(Thread.currentThread().getName() + "：开始生产第" + productor + "个产品");
//生产者生产了产品就可以唤醒消费者消费
notify();
}else{
//等待消费者消费
try{
wait();
}catch(InterruptedException e){
e.printStackTrace();
}
}
}
public synchronized void customerProductor(){
if(productor > 0){
System.out.println(Thread.currentThread().getName() + "：开始消费第" + productor + "个产品");
productor--;
//消费者消费了产品就可以唤醒生产者生产
notify();
}else{
//等待生产者生产
try{
wait();
}catch(InterruptedException e){
e.printStackTrace();
}
}
}
}
//生产者
class Producer extends Thread{
private Clerk clerk;
public Producer(Clerk clerk){
this.clerk = clerk;
}
public void run(){
System.out.println(getName() + "：开始生产产品。。。。。。");
while(true){
try{
Thread.sleep(20);
}catch(InterruptedException e){
e.printStackTrace();
}
clerk.producerProductor();
}
}
}
//消费者
class Customer extends Thread{
private Clerk clerk;
public Customer(Clerk clerk){
this.clerk = clerk;
}
public void run(){
System.out.println(getName() + "：开始消费产品。。。。。。");
while(true){
try{
Thread.sleep(50);
}catch(InterruptedException e){
e.printStackTrace();
}
clerk.customerProductor();
}
}
}
//测试类
public class ThreadDemo{
public static void main(String[] args){
//实例化一个店员
Clerk clerk = new Clerk();
//实例化一个生产者
Producer p1 = new Producer(clerk);
p1.setName("生产者1");
//实例化一个消费者
Customer c1 = new Customer(clerk);
c1.setName("消费者1");
Customer c2 = new Customer(clerk);
c2.setName("消费者2");
//执行线程
p1.start();
c1.start();
c2.start();
}
}
运行结果为：
因为没有停止条件，所以程序会一直跑，生产者生产，消费者消费。
6. JDK5.0新增线程的创建方式
新增方式一：实现Callable接口
- 与使用Runnable相比，Callable功能更强大些。
- 相比run()方法，可以有返回值。
- 方法可以抛出异常。
- 支持泛型的返回值。
- 需要借助FutureTask类，比如获取返回结果。
- Future接口
- 可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等。
- FutureTask是Future接口的唯一的实现类。
- FutureTask同时实现了Runnable，Future接口。它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值。
下面举例子来说明如何实现Callable接口：
//遍历1~100的偶数，并求和
//1.创建一个实现Callable接口的实现类
class NumThread implements Callable{
//2.实现call(),将此线程需要执行的操作声明在call()中
public Object call() throws Exception{
int sum = 0;
for(int i = 1;i <= 100;i++){
if(i % 2 == 0){
System.out.println(i);
sum += i;
}
}
return sum;
}
}
public class ThreadDemo{
public static void main(String[] args){
//3.创建Callable接口的实现类的对象
NumThread unmThread = new NumThread();
//4.将此Callable接口实现类的对象作为传递刀FutureTask的构造器中，创建FutureTask的对象
FutureTask futureTask = new FutureTask(unmThread);
//5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread类对象，并调用start()
Thread t1 = new Thread(futureTask);
t1.start();
try{
//6.获取Callable中call()的返回值
//get() 返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值
Object sum = futureTask.get();
System.out.println("总和为：" + sum);
}catch(InterruptedException e){
e.printStackTrace();
}catch(ExecutionException e){
e.printStackTrace();
}
}
}
运行结果为：
- 如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程的方式强大
- call() 可以有返回值。
- call() 可以抛出异常，被外面的操作捕获，获取异常的信息。
- Callable1是支持泛型的。
新增方式二：使用线程池
-
背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。
-
思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公交交通工具。
-
好处：
-
提高响应速度（减少了创建新线程的时间）
-
降低资源消耗（重复利用线程池中的线程，不需要每次都创建）
-
便于线程管理
corePoolSize：核心池的大小
maximumPoolSize：最大线程数
keepAliveTime：线程没有任务时最多保持多长时间后会终止
…
-
线程池相关API
- JDK 5.0 起提供线程池相关API：
ExecutorService和Executors。 - ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
- void execute(Runnable command)：执行任务/命令，没有返回值，一般用来执行Runnable。
<T>Future<T>submit(Callable<T>task)：执行任务，有返回值，一般用来执行Callable。- void shutdown()：关闭连接池。
- Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池。
- Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池。
- Executors.newFixedThreadPool(n)：创建一个可根据需要创建新线程的线程池。
- Executors.newSingleThreadExecutor()：创建一个只有一个线程的线程池。
- Executors.newScheduThreadPool(n)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。
下面用例子说明：
class NumberThread1 implements Runnable{
public void run(){
//遍历0~100的偶数
for(int i = 0;i <= 100;i++){
if(i % 2 == 0){
System.out.println(Thread.currentThread().getName() + "：" +i);
}
}
}
}
class NumberThread2 implements Runnable{
public void run(){
//遍历0~100的奇数
for(int i = 0;i <= 100;i++){
if(i % 2 != 0){
System.out.println(Thread.currentThread().getName() + "：" +i);
}
}
}
}
public class ThreadDemo{
public static void main(String[] args){
//1.提供指定线程数量的线程池
ExecutorService service = Executors.newFixedThreadPool(10);
//2.执行指定线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
service.execute(new NumberThread1); //适用于Runnable
service.execute(new NumberThread2);
//service.submit(Callable callable); //适用于Callable
//3.关闭连接池
service.shutdown();
}
}
运行结果为：
上面service.executre()方法里面提供参数的目的是为了告诉线程要做什么。那如何便于线程管理呢？
public class ThreadDemo{
public static void main(String[] args){
ExecutorService service = Executors.newFixedThreadPool(10);
//多态，强转
ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
//调用setCorePoolSize()
service1.setCorePoolSize(10);
service.shutdown();
}
}
面试题
创建多线程有几种方式？
一共四种：继承Thread类，实现Runnable接口，实现Callable接口，使用线程池。
7. 总结
本篇主要是对线程的创建、同步、使用进行说明。观看完本篇，我们应该熟知创建多线程的几种方式，它们是如何创建，如何使用的。
603
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
