Java的多线程编程

作者: 寻心_0a46 | 来源:发表于2023-05-15 11:00 被阅读0次

2018-10-16
线程(Thread)
史上最全Java多线程面试题及答案
Java多线程高级特性（JDK8）
Java多线程学习：Future、Callable
Java多线程
Java多线程
使用JDK自带的工具jstack找出造成运行程序死锁的原因
Java多线程编程核心技术【笔记】
Java架构师阅读书单

Java 给多线程编程提供了内置的支持。 一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。

多线程是多任务的一种特别的形式，但多线程使用了更小的资源开销。多线程能满足程序员编写高效率的程序来达到充分利用 CPU 的目的。

这里定义和线程相关的另一个术语 - 进程：一个进程包括由操作系统分配的内存空间，包含一个或多个线程。一个线程不能独立的存在，它必须是进程的一部分。一个进程一直运行，直到所有的非守护线程都结束运行后才能结束。

一个线程的生命周期

线程是一个动态执行的过程，它也有一个从产生到死亡的过程。下图显示了一个线程完整的生命周期：

java-thread.jpg

新建状态：使用 new 关键字和 Thread 类或其子类建立一个线程对象后，该线程对象就处于新建状态。它保持这个状态直到程序 start() 这个线程。

就绪状态：当线程对象调用了start()方法之后，该线程就进入就绪状态。就绪状态的线程处于就绪队列中，要等待JVM里线程调度器的调度。

运行状态：如果就绪状态的线程获取 CPU 资源，就可以执行 run()，此时线程便处于运行状态。处于运行状态的线程最为复杂，它可以变为阻塞状态、就绪状态和死亡状态。

阻塞状态：如果一个线程执行了sleep（睡眠）、suspend（挂起）等方法，失去所占用资源之后，该线程就从运行状态进入阻塞状态。在睡眠时间已到或获得设备资源后可以重新进入就绪状态。可以分为三种：

等待阻塞：运行状态中的线程执行 wait() 方法，使线程进入到等待阻塞状态。
同步阻塞：线程在获取 synchronized 同步锁失败(因为同步锁被其他线程占用)。
其他阻塞：通过调用线程的 sleep() 或 join() 发出了 I/O 请求时，线程就会进入到阻塞状态。当sleep() 状态超时，join() 等待线程终止或超时，或者 I/O 处理完毕，线程重新转入就绪状态。

死亡状态：一个运行状态的线程完成任务或者其他终止条件发生时，该线程就切换到终止状态。

线程的优先级

每一个 Java 线程都有一个优先级，线程的优先级有助于操作系统确定线程的调度顺序。

Java 线程的优先级是一个整数，其取值范围是 1 （Thread.MIN_PRIORITY ） - 10 （Thread.MAX_PRIORITY ）。默认情况下，每一个线程都会分配一个优先级 NORM_PRIORITY（5）。

具有较高优先级的线程对程序更重要，并且应该在低优先级的线程之前分配处理器资源。但是，线程优先级并不能保证线程执行的顺序，而且非常依赖于平台。

创建一个线程的方法

Java 提供了三种创建线程的方法：

通过实现 Runnable 接口；
通过继承 Thread 类本身；
通过 Callable 和 Future 创建线程。

通过实现 Runnable 接口来创建线程：创建一个线程，最简单的方法是创建一个实现 Runnable 接口的类。为了实现 Runnable，一个类只需要执行一个方法调用 run()，声明如下：

public void run()

可以重写该方法，重要的是理解的 run() 可以调用其他方法，使用其他类，并声明变量，就像主线程一样。

在创建一个实现 Runnable 接口的类之后，可以在类中实例化一个线程对象。
Thread 定义了几个构造方法，下面的这个是经常使用的：

// threadOb 是一个实现 Runnable 接口的类的实例，并且 threadName 指定新线程的名字
Thread(Runnable threadOb,String threadName);

新线程创建之后，调用它的 start() 方法它才会运行。声明如下：

void start();

下面是一个创建线程并开始让它执行的实例：

public class RunnableDemo implements Runnable{
    // 线程对象
    private Thread t;
    // 线程名称
    private String threadName;

    // 构造方法
    RunnableDemo( String name) {
        threadName = name;
        System.out.println("Creating " +  threadName );
    }

    // 实现 run() 抽象方法
    public void run() {
        System.out.println("Running " +  threadName );
        try {
            for(int i = 4; i > 0; i--) {
                System.out.println("Thread: " + threadName + ", " + i);
                // 让线程睡眠一会
                Thread.sleep(50);
            }
        }catch (InterruptedException e) {
            System.out.println("Thread " +  threadName + " interrupted.");
        }
        System.out.println("Thread " +  threadName + " exiting.");
    }

    // 运行线程
    public void start () {
        System.out.println("Starting " +  threadName );
        if (t == null) {
            t = new Thread (this, threadName);
            // 线程开始执行
            t.start ();
        }
    }
}

public class TestThread {

    public static void main(String args[]) {
        RunnableDemo R1 = new RunnableDemo( "Thread-1");
        R1.start();

        RunnableDemo R2 = new RunnableDemo( "Thread-2");
        R2.start();
    }
}

// 程序运行结果如下：
// Creating Thread-1
// Starting Thread-1
// Creating Thread-2
// Starting Thread-2
// Running Thread-1
// Thread: Thread-1, 4
// Running Thread-2
// Thread: Thread-2, 4
// Thread: Thread-1, 3
// Thread: Thread-2, 3
// Thread: Thread-1, 2
// Thread: Thread-2, 2
// Thread: Thread-1, 1
// Thread: Thread-2, 1
// Thread Thread-2 exiting.
// Thread Thread-1 exiting.

// Process finished with exit code 0

通过继承Thread来创建线程：创建一个线程的第二种方法是创建一个新的类，该类继承 Thread 类，然后创建一个该类的实例。继承类必须重写 run() 方法，该方法是新线程的入口点。它也必须调用 start() 方法才能执行。通过继承Thread来创建线程尽管被列为一种多线程实现方式，但是本质上也是实现了 Runnable 接口的一个实例：

class ThreadDemo extends Thread {
   private Thread t;
   private String threadName;
   
   ThreadDemo( String name) {
      threadName = name;
      System.out.println("Creating " +  threadName );
   }
   
   public void run() {
      System.out.println("Running " +  threadName );
      try {
         for(int i = 4; i > 0; i--) {
            System.out.println("Thread: " + threadName + ", " + i);
            // 让线程睡眠一会
            Thread.sleep(50);
         }
      }catch (InterruptedException e) {
         System.out.println("Thread " +  threadName + " interrupted.");
      }
      System.out.println("Thread " +  threadName + " exiting.");
   }
   
   public void start () {
      System.out.println("Starting " +  threadName );
      if (t == null) {
         t = new Thread (this, threadName);
         t.start ();
      }
   }
}
 
public class TestThread {
 
   public static void main(String args[]) {
      ThreadDemo T1 = new ThreadDemo( "Thread-1");
      T1.start();
      
      ThreadDemo T2 = new ThreadDemo( "Thread-2");
      T2.start();
   }   
}

// 程序运行结果如下：
// Creating Thread-1
// Starting Thread-1
// Creating Thread-2
// Starting Thread-2
// Running Thread-1
// Thread: Thread-1, 4
// Running Thread-2
// Thread: Thread-2, 4
// Thread: Thread-1, 3
// Thread: Thread-2, 3
// Thread: Thread-2, 2
// Thread: Thread-1, 2
// Thread: Thread-2, 1
// Thread: Thread-1, 1
// Thread Thread-1 exiting.
// Thread Thread-2 exiting.

// Process finished with exit code 0

下表列出了Thread类的一些重要方法（Thread 对象调用）：

序号	方法及说明
1	public void start()，使该线程开始执行；Java 虚拟机调用该线程的 run 方法
2	public void run()，如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法；否则，该方法不执行任何操作并返回
3	public final void setName(String name)，改变线程名称，使之与参数 name 相同
4	public final void setPriority(int priority)，更改线程的优先级
5	public final void setDaemon(boolean on)，将该线程标记为守护线程或用户线程
6	public final void join(long millisec)，会让运行到（不是调用方）该方法的线程处于阻塞状态，阻塞的最长时间为 millis 毫秒（0或无参会无限等待），知道调用该方法的线程运行完毕或是到达等待最长时间后解除运行该方法的线程的阻塞状态
7	public void interrupt()，中断一个正在运行的线程，若是该线程正处于某种阻塞时被调用中断方法中断，那么并不是将该线程直接中断，而是中断其阻塞状态，这时通常会抛出异常，通知程序该线程的阻塞状态被打断
8	public final boolean isAlive()，测试线程是否处于活动状态

下面表格的方法是 Thread 类的静态方法：

序号	方法及说明
1	public static void yield()，暂停当前正在执行的线程对象，并执行其他线程
2	public static void sleep(long millisec)，在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。
3	public static boolean holdsLock(Object x)，当且仅当当前线程在指定的对象上保持监视器锁时，才返回 true
4	public static Thread currentThread()，返回对当前正在执行的线程对象的引用
5	public static void dumpStack()，将当前线程的堆栈跟踪打印至标准错误流

通过 Callable 和 Future 创建线程：

1. 创建 Callable 接口的实现类，并实现 call() 方法，该 call() 方法将作为线程执行体，并且有返回值。
1. 创建 Callable 实现类的实例，使用 FutureTask 类来包装 Callable 对象，该 FutureTask 对象封装了该 Callable 对象的 call() 方法的返回值。
1. 使用 FutureTask 对象作为 Thread 对象的 target 创建并启动新线程。
1. 调用 FutureTask 对象的 get() 方法来获得子线程执行结束后的返回值。

package Thread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

// 创建 Callable 接口的实现类
public class CallableThreadTest implements Callable {
    public static void main(String[] args)
    {
        //  创建 Callable 实现类的实例，使用 FutureTask 类来包装 Callable 对象
        CallableThreadTest ctt = new CallableThreadTest();
        FutureTask<Integer> ft = new FutureTask<>(ctt);
        for(int i = 0;i < 100;i++)
        {
            // 主线程输出
            System.out.println(Thread.currentThread().getName()+" 的循环变量i的值"+i);
            if(i==20)
            {
                // 以 FutureTask 对象 和 新线程的名称 创建并启动子线程
                new Thread(ft,"有返回值的线程").start();
            }
        }
        try
        {
            // 输出子线程执行结束后的返回值
            System.out.println("子线程的返回值："+ft.get());
        } catch (InterruptedException e)
        {
            e.printStackTrace();
        } catch (ExecutionException e)
        {
            e.printStackTrace();
        }

    }
    // 实现 call() 方法，该 call() 方法将作为线程执行体，并且有返回值
    @Override
    public Integer call() throws Exception
    {
        int i = 0;
        for(;i<100;i++)
        {
            // 子线程输出
            System.out.println(Thread.currentThread().getName()+" "+i);
        }
        return I;
    }
}

创建线程的三种方式的对比：

1. 采用实现 Runnable、Callable 接口的方式创建多线程时，线程类只是实现了 Runnable 接口或 Callable 接口，还可以继承其他类。
1. 使用继承 Thread 类的方式创建多线程时，编写简单，如果需要访问当前线程，则无需使用 Thread.currentThread() 方法，直接使用 this 即可获得当前线程。

线程的几个主要概念

在多线程编程时，需要了解以下几个概念：

线程同步
线程死锁
线程间通信
线程控制：挂起、停止和恢复

线程同步：即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作，其他线程才能对该内存地址进行操作。

同步方法：在一个方法上使用 synchronized 修饰后，那么该方法称为“同步方法”，即多个线程不能同时在方法内部执行，从而解决并发安全问题。静态方法使用 synchronized 修饰后，那么该方法一定具有同步效果。声明格式如下：

public synchronized 返回值类型 方法名（）{}

同步块：在需要同步运行的代码片段上使用 synchronized 修饰后，那么该代码块称为“同步块”，有效的缩小同步范围可以在保证并发安全的前提下尽可能的提高并发效率。声明格式如下：

synchronized (同步监视器) {
   需要同步运行的代码片段
}

同步监视器：同步监视器可以是 Java 中任意的一个对象。在“同步方法”中，同步监视器对象就是当前方法所属对象，即方法内部看到的 this。在“同步块”中，只要保证多个线程看到的该对象是‘同一个’，即可保证同步块中的代码是并发安全的。

使用“同步块”的实例：

package Thread;

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

// 创建 Callable 接口的实现类
public class CallableThreadTest implements Callable {
    public static void main(String[] args)
    {
        //  创建 Callable 实现类的实例，使用 FutureTask 类来包装 Callable 对象
        CallableThreadTest ctt = new CallableThreadTest();
        FutureTask<Integer> ft = new FutureTask<>(ctt);
        FutureTask<Integer> ft2 = new FutureTask<>(ctt);
       
        // 以 FutureTask 对象 和 新线程的名称 创建并启动子线程
        Thread t1 = new Thread(ft,"有返回值的线程");
        t1.start();
        Thread t2 = new Thread(ft2,"有返回值的线程2");
        t2.start();
    }
    // 实现 call() 方法，该 call() 方法将作为线程执行体，并且有返回值
    @Override
    public Integer call() throws Exception
    {
        synchronized (this){
            int i = 0;
            for(;i<100;i++)
            {
            // 子线程输出
            System.out.println(Thread.currentThread().getName()+" "+i);

            }
            return I;
        }
    }
}

// 程序运行结果如下：
// 使用同步块的情况下，一个线程会完成循环后，另一个线程再开始循环
// 不实用同步块的情况下，两个线程中的循环交替进行

线程互斥锁：当使用 synchronized 锁住多段不同的代码片段，但是这些同步块使用的同步监视器对象是同一个时，那么这些代码片段之间就是互斥的，多个线程不能同时执行他们。

线程死锁：当多个线程都持有自己的锁，但都等对方先释放锁时，就会出现‘僵持’的情况，使得所有线程进入阻塞状态，这个现象称为死锁现象。

线程间通信：当多个线程共同操作共享的资源时，线程间通过某种方式互相告知自己的状态，以避免无效的资源争夺。线程间通信的方式可以有很多种：等待-通知、共享内存、管道流。每种方式用不同的方法来实现。

线程控制：Java提供对多线程程序的完全控制。可以开发一个多线程程序，根据要求完全暂停，恢复或停止。可以在线程对象上使用各种静态方法来控制它们的行为。

挂起：线程挂起就是指暂停线程的执行(阻塞状态)，挂起时线程不会释放对象锁。
恢复：恢复就是让暂停的线程得以继续执行.(返回就绪状态)。
停止：停止一个线程时会强制结束线程的执行，不管run方法是否执行完了，并且还会释放这个线程所持有的所有的锁对象。

死锁及解决方法

死锁是这样一种情形：多个线程同时被阻塞，它们中的一个或者全部都在等待某个资源被释放。由于线程被无限期地阻塞，因此程序不可能正常终止。

java 死锁产生的四个必要条件：

1、互斥使用，即当资源被一个线程使用(占有)时，别的线程不能使用。
2、不可抢占，资源请求者不能强制从资源占有者手中夺取资源，资源只能由资源占有者主动释放。
3、请求和保持，即当资源请求者在请求其他的资源的同时保持对原有资源的占有。
4、循环等待，即存在一个等待队列：P1占有P2的资源，P2占有P3的资源，P3占有P1的资源。这样就形成了一个等待环路。

当上述四个条件都成立的时候，便形成死锁。当然，死锁的情况下如果打破上述任何一个条件，便可让死锁消失。下面用java代码来模拟一下死锁的产生：

public class LockTest {
    public static String obj1 = "obj1";
    public static String obj2 = "obj2";
    public static void main(String[] args) {
        LockA la = new LockA();
        new Thread(la).start();
        LockB lb = new LockB();
        new Thread(lb).start();
    }
}

class LockA implements Runnable{
    public void run() {
        try {
            System.out.println(new Date().toString() + " LockA 开始执行");
            while(true){
                synchronized (LockTest.obj1) {
                    System.out.println(new Date().toString() + " LockA 锁住 obj1");
                    // 此处等待是给B能锁住机会
                    Thread.sleep(3000);
                    synchronized (LockTest.obj2) {
                        System.out.println(new Date().toString() + " LockA 锁住 obj2");
                        // 为测试，占用了就不放
                        Thread.sleep(60 * 1000);
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class LockB implements Runnable{
    public void run() {
        try {
            System.out.println(new Date().toString() + " LockB 开始执行");
            while(true){
                synchronized (LockTest.obj2) {
                    System.out.println(new Date().toString() + " LockB 锁住 obj2");
                    // 此处等待是给A能锁住机会
                    Thread.sleep(3000);
                    synchronized (LockTest.obj1) {
                        System.out.println(new Date().toString() + " LockB 锁住 obj1");
                        // 为测试，占用了就不放
                        Thread.sleep(60 * 1000);
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

// 以上程序执行结果为：
// Fri May 12 12:59:39 CST 2023 LockA 开始执行
// Fri May 12 12:59:39 CST 2023 LockB 开始执行
// Fri May 12 12:59:39 CST 2023 LockA 锁住 obj1
// Fri May 12 12:59:39 CST 2023 LockB 锁住 obj2

由于不恰当的使用了锁，且出现同时锁住多个对象时，上例中便发生了死锁，LockA 的 run() 方法执行后，率先锁住 obj1 对象，之后 LockA 中的线程进入休眠，期间 LockB 的 run() 方法中锁住 obj2 对象。当 LockA 中的线程睡醒后，准备去锁住 obj2 对象，结果发现 obj2 对象已经被 LockB 锁住，只能站着等 LockB 撒手。而 LockB 中的线程睡醒后，准备去锁住 obj1 对象，结果发现 obj1 对象已经被 LockA 锁住，结果也只能站着等 LockA 撒手。最终 LockA 与 LockB 都站下了，程序也就站下了。

为了解决这个问题，我们可以不使用显示的去锁，而使用信号量去控制。信号量可以控制资源能被多少线程访问，这里我们指定只能被一个线程访问，就做到了类似锁住。而信号量可以指定去获取的超时时间，我们可以根据这个超时时间，去做一个额外处理。对于无法成功获取的情况，可以采取重复尝试，或指定尝试的次数，也可以马上退出：

public class UnLockTest {
    // 同步观察对象
    public static String obj1 = "obj1";
    public static String obj2 = "obj2";
    // 信号量，初始许可操作数为1
    public static final Semaphore a1 = new Semaphore(1);
    public static final Semaphore a2 = new Semaphore(1);
    
    public static void main(String[] args) {
        NewLockA la = new NewLockA();
        new Thread(la).start();
        NewLockB lb = new NewLockB();
        new Thread(lb).start();
    }
}

class NewLockA implements Runnable {
    public void run() {
        try {
            System.out.println(new Date().toString() + " LockA 开始执行");
            // 无限次的重复尝试获取锁，直到成功，对，就是这么执着
            while (true) {
                // 判断信号量 a1 是否许可使用，等待信号量 a1 许可的时间最长 1 秒
                if (UnLockTest.a1.tryAcquire(1, TimeUnit.SECONDS)) {
                    System.out.println(new Date().toString() + " LockA 锁住 obj1");
                    // 判断信号量 a2 是否许可使用，等待信号量 a2 许可的时间最长 1 秒
                    if (UnLockTest.a2.tryAcquire(1, TimeUnit.SECONDS)) {
                        System.out.println(new Date().toString() + " LockA 锁住 obj2");
                        // LockA 同时锁住 obj1 与 obj2，这里可以进行操作，睡一下
                        System.out.println("LockA 可以安心操作了");
                        Thread.sleep(10 * 1000);
                        // 释放信号量
                        UnLockTest.a1.release();
                        UnLockTest.a2.release();
                        // 跳出循环
                        break;
                    }else{
                        // 信号量 a2 不可用、或等待信号量许可超时
                        System.out.println(new Date().toString() + " LockA 锁 obj2 失败");
                    }
                }else{
                    // 信号量 a1 不可用、或等待信号量许可超时
                    System.out.println(new Date().toString() + " LockA 锁 obj1 失败");
                }
                // 释放信号量
                UnLockTest.a1.release();
                UnLockTest.a2.release();
                // 上锁失败了，暂停当前正在执行的线程对象，并执行其他线程
                Thread.yield();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class NewLockB implements Runnable {
    public void run() {
        try {
            System.out.println(new Date().toString() + " LockB 开始执行");
            // 无限次的重复尝试获取锁，直到成功，对，就是这么执着
            while (true) {
                if (UnLockTest.a2.tryAcquire(1, TimeUnit.SECONDS)) {
                    System.out.println(new Date().toString() + " LockB 锁住 obj2");
                    if (UnLockTest.a1.tryAcquire(1, TimeUnit.SECONDS)) {
                        System.out.println(new Date().toString() + " LockB 锁住 obj1");
                        // LockB 同时锁住 obj1 与 obj2，这里可以进行操作，睡一下
                        System.out.println("LockB 可以安心操作了");
                        Thread.sleep(10 * 1000);
                        // 释放信号量
                        UnLockTest.a1.release();
                        UnLockTest.a2.release();
                        // 跳出循环
                        break;
                    }else{
                        System.out.println(new Date().toString() + " LockB 锁 obj1 失败");
                    }
                }else{
                    System.out.println(new Date().toString() + " LockB 锁 obj2 失败");
                }
                // 释放信号量
                UnLockTest.a1.release();
                UnLockTest.a2.release();
                // 上锁失败了，暂停当前正在执行的线程对象，并执行其他线程
                Thread.yield();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

// 以上程序执行结果为：
// Fri May 12 21:39:40 CST 2023 LockB 开始执行
// Fri May 12 21:39:40 CST 2023 LockA 开始执行
// Fri May 12 21:39:40 CST 2023 LockB 锁住 obj2
// Fri May 12 21:39:40 CST 2023 LockA 锁住 obj1
// Fri May 12 21:39:41 CST 2023 LockB 锁 obj1 失败
// Fri May 12 21:39:41 CST 2023 LockB 锁住 obj2
// Fri May 12 21:39:41 CST 2023 LockA 锁 obj2 失败
// Fri May 12 21:39:41 CST 2023 LockB 锁住 obj1
// LockB 可以安心操作了
// Fri May 12 21:39:41 CST 2023 LockA 锁住 obj1
// Fri May 12 21:39:41 CST 2023 LockA 锁住 obj2
// LockA 可以安心操作了

生产者/消费者问题

生产者和消费者问题是线程模型中的经典问题：生产者和消费者在同一时间段内共用同一个存储空间，如下图所示，生产者向空间里存放数据，而消费者取用数据，如果不加以协调可能会出现以下情况：

存储空间已满，而生产者占用着它，消费者等着生产者让出空间从而取出产品，生产者等着消费者消费产品，从而向空间中添加产品。互相等待，从而发生死锁。

2011091018554595.gif

以下实例演示了如何通过线程解决生产者/消费者问题：

public class ProducerConsumerTest {
    public static void main(String[] args) {
        CubbyHole c = new CubbyHole();
        Producer p1 = new Producer(c, 1);
        p1.setPriority(Thread.MAX_PRIORITY);
        p1.start();
        Consumer c1 = new Consumer(c, 1);
        c1.setPriority(Thread.MIN_PRIORITY);
        c1.start();
    }
}

/**
 * 仓库类
 */
class CubbyHole {
    // 仓库中的产品，这里的产品是一个整数
    private int contents;
    // 是否可以在仓库中取出产品
    private boolean available = false;

    /**
     * 同步方法，在仓库获取产品
     * @return 产品
     */
    public synchronized int get() {
        // 如果不可以在仓库中取出产品，就应该等待仓库放入商品，所以该对象上的线程就进入无限期的等待
        while (available == false) {
            try {
                wait();
            }
            catch (InterruptedException e) {
            }
        }
        // 如果可以在仓库中取出产品，取出商品，唤醒在该对象上等待的所有线程，再次标记为不可以在仓库中取出商品
        available = false;
        notifyAll();
        return contents;
    }

    /**
     * 同步方法，向仓库放入商品
     * @param value 商品
     */
    public synchronized void put(int value) {
        // 如果可以在仓库中取出产品，那么就不再放入商品，所以该对象上的线程就进入无限期的等待
        while (available == true) {
            try {
                wait();
            }
            catch (InterruptedException e) {
            }
        }
        // 如果不可以在仓库中取出产品了，说明仓库没货了，可以放入商品
        contents = value;
        // 放入商品后，标记为可以取出产品了
        available = true;
        // 唤醒在该对象上等待的所有线程
        notifyAll();
    }
}

/**
 * 生产者类
 */
class Producer extends Thread {
    // 仓库对象
    private CubbyHole cubbyhole;
    // 生产者编号
    private int number;

    /**
     * 生产者构造方法
     * @param c 仓库对象
     * @param number 生产者编号
     */
    public Producer(CubbyHole c, int number) {
        cubbyhole = c;
        this.number = number;
    }

    public void run() {
        for (int i = 0; i < 5; i++) {
            // 向仓库放入商品
            cubbyhole.put(i);
            System.out.println("生产者 #" + this.number + " 向仓库放入: " + i);
            try {
                // 睡一下，让出Cpu时间片
                sleep((int)(Math.random() * 100));
            } catch (InterruptedException e) { }
        }
    }
}

/**
 * 消费者类
 */
class Consumer extends Thread {
    // 仓库对象
    private CubbyHole cubbyhole;
    // 消费者编号
    private int number;

    /**
     * 消费者构造方法
     * @param c 仓库对象
     * @param number 消费者编号
     */
    public Consumer(CubbyHole c, int number) {
        cubbyhole = c;
        this.number = number;
    }
    public void run() {
        int value = 0;
        for (int i = 0; i < 5; i++) {
            // 在仓库取出商品
            value = cubbyhole.get();
            System.out.println("消费者 #" + this.number+ " 在仓库取出: " + value);
        }
    }
}

// 以上程序执行结果为：
// 生产者 #1 向仓库放入: 0
// 消费者 #1 在仓库取出: 0
// 生产者 #1 向仓库放入: 1
// 消费者 #1 在仓库取出: 1
// 生产者 #1 向仓库放入: 2
// 消费者 #1 在仓库取出: 2
// 生产者 #1 向仓库放入: 3
// 消费者 #1 在仓库取出: 3
// 生产者 #1 向仓库放入: 4
// 消费者 #1 在仓库取出: 4

多线程的使用

有效利用多线程的关键是理解程序是并发执行而不是串行执行的。例如：程序中有两个子系统需要并发执行，这时候就需要利用多线程编程。通过对多线程的使用，可以编写出非常高效的程序。不过请注意，如果创建太多的线程，程序执行的效率实际上是降低了，而不是提升了。因为上下文的切换开销也很重要，如果创建了太多的线程，CPU 花费在上下文的切换的时间将多于执行程序的时间！

线程池

线程池是一个容纳多个线程的容器，可以实现线程的复用，避免了反复创建线程的资源消耗。线程池的主要作用如下：

控制线程数量：每个线程都会占用进程的一部分内存，线程的数量过多会导致资源消耗大，由于所有的线程都是并发运行，那么过多的线程也会导致CPU过度切换，导致并发效率变差。
重用线程：频繁的创建销毁线程会给线程调度带来负担，所以也应当重用线程。

可以使用 Runnable 接口创建线程池：

public class ThreadPool {
    public static void main(String[] args) {
        // 创建任务
        TaskRunnable task = new TaskRunnable();
        // 创建固定大小的线程池
        ExecutorService threadPool =  Executors.newFixedThreadPool(2);
        // 将任务指派给线程池
        // execute只能提交Runnable类型的任务，没有返回值
        threadPool.execute(task);
        threadPool.execute(task);
        threadPool.execute(task);
        // 有序的停止线程池中的任务，在 awaitTermination() 方法中等待子线程任务完成后，停止线程池
        threadPool.shutdown();
        //等待直到所有任务完成
        try {
            System.out.println("等待子线程完成任务。。。");
            // 阻塞，等待子线程任务完成，或达到超时时间，解除阻塞
            threadPool.awaitTermination(Long.MAX_VALUE, TimeUnit.MINUTES);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("任务都完成了，退出程序！");
    }
}

/**
 * 任务类
 */
class TaskRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("子线程任务开始了。。。");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException x) {
            System.out.println(x);
        }
        System.out.println("子线程任务完成了!");
    }
}

// 以上程序执行结果为：
// 等待子线程完成任务。。。
// 子线程任务开始了。。。
// 子线程任务开始了。。。
// 子线程任务完成了!
// 子线程任务开始了。。。
// 子线程任务完成了!
// 子线程任务完成了!
// 任务都完成了，退出程序！

使用Callable接口创建线程池：

public class ThreadPool {
    public static void main(String[] args) {
        // 创建任务
        TaskCallable task = new TaskCallable("future 任务");
        TaskCallable task2 = new TaskCallable("普通任务");
        // 创建固定大小的线程池
        ExecutorService threadPool =  Executors.newFixedThreadPool(2);
        // submit 可以提交 Callable 与 Runnable 类型的任务，有返回值
        Future future = threadPool.submit(task);
        threadPool.submit(task2);
        threadPool.submit(task2);
        threadPool.submit(task2);
        try {
            System.out.println("阻塞，至少等待 future 任务完成");
            // 阻塞线程，等待结果
            future.get();
        }catch (Exception e) {
            System.out.println(e);
        }
        // 尽力终止线程池执行任务(不保证一定终止)，通过Thread.interrupt终止
        // 例如线程休眠的话，该方法不会在 awaitTermination() 方法中等待
        threadPool.shutdownNow();
        // 等待直到所有任务完成，这里 shutdownNow() 方法不会在这里等待， 所以无效的
        try {
            System.out.println("等待子线程完成任务。。。");
            // 阻塞，等待子线程任务完成，或达到超时时间，解除阻塞
            threadPool.awaitTermination(Long.MAX_VALUE, TimeUnit.MINUTES);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("任务都完成了，退出程序！");
    }
}

/**
 * 任务类
 */
class TaskCallable implements Callable {
    private String taskName;

    TaskCallable(String taskName) {
        this.taskName = taskName;
    }

    @Override
    public Object call() throws Exception {
        System.out.println(this.taskName + "开始了。。。");
        try {
            Thread.sleep(2000);
            System.out.println(this.taskName + "完成了!");
        } catch (InterruptedException x) {
            System.out.println(this.taskName + "被打断了!!");
        }
        return null;
    }
}

// 以上程序执行结果为：
// future 任务开始了。。。
// 阻塞，至少等待 future 任务完成
// 普通任务开始了。。。
// future 任务完成了!
// 普通任务完成了!
// 普通任务开始了。。。
// 普通任务开始了。。。
// 等待子线程完成任务。。。
// 普通任务被打断了!!
// 普通任务被打断了!!
// 任务都完成了，退出程序！

$\color{red}{方法实例：}$

isAlive() 方法：

public final boolean isAlive()

描述：

测试线程是否处于活动状态。如果线程已启动，但尚未终止，则它是活动的。

参数：

无

返回值：

如果此线程是活动的，则为true；否则为false。

public class TestThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            printMsg();
        }
    }

    /**
     * 打印当前线程
     */
    public void printMsg() {
        Thread t = Thread.currentThread();
        String name = t.getName();
        System.out.println("name=" + name);
    }

    public static void main(String[] args) {
        TestThread tt = new TestThread();
        tt.setName("Thread");
        System.out.println("执行 start()方法 之前, tt.isAlive()=" + tt.isAlive());
        tt.start();
        System.out.println("执行 start()方法 之后, tt.isAlive()=" + tt.isAlive());
        for (int i = 0; i < 5; i++) {
            tt.printMsg();
        }
        System.out.println("main() 方法结束, tt.isAlive()=" + tt.isAlive());
    }
}

// 以上程序执行结果为：
// 执行 start()方法 之前, tt.isAlive()=false
// 执行 start()方法 之后, tt.isAlive()=true
// name=main
// name=main
// name=main
// name=main
// name=main
// main() 方法结束, tt.isAlive()=true
// name=Thread
// name=Thread
// name=Thread
// name=Thread
// name=Thread

getState() 方法：

public State getState()

描述：

返回此线程的状态。此方法设计用于监测系统状态，而不是用于同步控制。

参数：

无

返回值：

这个线程的状态。

注意：

线程状态分为：

NEW -- 尚未启动的线程的线程状态。
RUNNABLE -- 可运行线程的线程状态。处于可运行状态的线程正在Java虚拟机中执行，但它可能正在等待来自操作系统（如处理器）的其他资源。
BLOCKED -- 被阻止等待监视器锁定的线程的线程状态。处于阻塞状态的线程正在等待监视器锁进入同步的块/方法，或者在调用 Object.wait 后重新进入同步块/方法。
WAITING -- 等待线程的线程状态。由于调用以下方法之一，线程处于等待状态：未设置超时时间的 Object.wait()、未设置超时时间的 Thread.join()、LockSupport.park。处于等待状态的线程正在等待另一个线程执行特定操作。
TIMED_WAITING -- 具有指定等待时间的等待线程的线程状态。由于使用指定的正等待时间调用以下方法之一，线程处于定时等待状态：Thread.sleep、设置超时时间的 Object.wait()、设置超时时间的 Thread.join()、LockSupport.parkNanos、
LockSupport.parkUntil。
TERMINATED -- 已终止线程的线程状态。线程已完成执行。

public class TestThread extends Thread {
    boolean waiting= true;
    boolean ready= false;

    TestThread() {
    }

    public void run() {
        String thrdName = Thread.currentThread().getName();
        System.out.println(thrdName + " starting.");
        while(waiting) {
            System.out.println("waiting:" + waiting);
        }
        System.out.println("waiting...");
        startWait();
        try {
            Thread.sleep(1000);
        } catch(Exception exc) {
            System.out.println(thrdName + " interrupted.");
        }
        System.out.println(thrdName + " 停止.");
    }

    /**
     * 开始等待
     */
    synchronized void startWait() {
        try {
            // 让当前线程进入等待状态
            while(!ready) wait();
        } catch(InterruptedException exc) {
            System.out.println("wait() interrupted");
        }
    }

    /**
     * 通知结束线程等待
     */
    synchronized void notice() {
        ready = true;
        // 唤醒在该对象上等待的某个线程
        notify();
    }

    public static void main(String args[]) throws Exception {
        TestThread thrd = new TestThread();
        thrd.setName("MyThread #1");
        // MyThread #1Alive:=false State:=NEW
        showThreadStatus(thrd);
        thrd.start();
        Thread.sleep(50);
        // MyThread #1Alive:=true State:=RUNNABLE
        showThreadStatus(thrd);
        thrd.waiting = false;
        Thread.sleep(50);
        // MyThread #1Alive:=true State:=WAITING
        showThreadStatus(thrd);
        thrd.notice();
        Thread.sleep(50);
        // MyThread #1Alive:=true State:=RUNNABLE
        showThreadStatus(thrd);
        while(thrd.isAlive()) {
            System.out.println("alive");
        }
        // MyThread #1Alive:=false State:=TERMINATED
        showThreadStatus(thrd);
    }

    /**
     * 打印线程状态
     * @param thrd Thread 对象
     */
    static void showThreadStatus(Thread thrd) {
        System.out.println(thrd.getName() + "Alive:=" + thrd.isAlive() + " State:=" + thrd.getState());
    }
}

// 以上程序执行结果为：
// MyThread #1Alive:=false State:=NEW
// MyThread #1 starting.
// waiting:true
// 。。。
// MyThread #1Alive:=true State:=RUNNABLE
// waiting:true
// waiting:false
// waiting...
// MyThread #1Alive:=true State:=WAITING
// MyThread #1 停止.
// MyThread #1Alive:=false State:=TERMINATED

setPriority() 方法：

public final void setPriority(int newPriority)

描述：

更改此线程的优先级。

参数：

newPriority -- 将此线程设置为的优先级。

返回值：

无

public class TestThread extends Thread {
    private int countDown = 5;
    private volatile double d = 0;
    public TestThread(int priority) {
        setPriority(priority);
        start();
    }
    public String toString() {
        return super.toString() + ": " + countDown;
    }
    public void run() {
        while(true) {
            for(int i = 1; i < 100000; i++) {
                d = d + (Math.PI + Math.E) / (double) I;
            }
            System.out.println(this);
            if(--countDown == 0) {
                return;
            }
        }
    }
    public static void main(String[] args) {
        TestThread maxThread = new TestThread(Thread.MAX_PRIORITY);
        maxThread.setName("maxThread");
        for(int i = 0; i < 5; i++) {
            TestThread minThreadnew = new TestThread(Thread.MIN_PRIORITY);
            minThreadnew.setName("minThreadnew");
        }
    }
}

join() 方法：

// 该方法有以下几种语法格式：
public final void join() throws InterruptedException
public final synchronized void join(long millis) throws InterruptedException
public final synchronized void join(long millis, int nanos) throws InterruptedException

描述：

运行到该方法的代码线程进入阻塞状态，调用该方法的线程进入运行状态，最长阻塞时间为 millis 毫秒。

参数：

millis -- 等待的时间（以毫秒为单位）。
nanos -- 额外的纳秒等待（范围0-999999）。设置后等待时间为 millis + nanos。

注意：

如果millis的值为负数，或者nanos的值不在0-999999的范围内，抛出IllegalArgumentException。
如果有线程中断了当前线程，抛出InterruptedException。当抛出此异常时，当前线程的中断状态将被清除。

public class TestThread extends Thread {
    private int countDown = 2;
    private static int threadCount = 0;
    private Thread mainThread;

    /**
     * 构造方法，threadCount每次先进行自增，作为线程名
     */
    public TestThread(Thread mainTThread) {
        super("" + ++threadCount);
        this.mainThread = mainTThread;
        System.out.println("TestThread 的 start() 方法之前，主线程状态：" + this.mainThread.getState());
        start();
    }

    @Override
    public String toString() {
        return "#" + getName() + ": " + countDown;
    }

    @Override
    public void run() {
        System.out.println("TestThread 的 run() 方法执行中，主线程状态：" + this.mainThread.getState());
        while (true) {
            System.out.println(this);
            if (--countDown == 0)
                return;
            try {
                sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 2; i++) {
            // 主线程代码运行到 join() 方法后，会将主线程挂起，并等待 TestThread 运行完毕后恢复运行
            new TestThread(Thread.currentThread()).join();
            System.out.println("TestThread 执行完成，主线程状态：" + Thread.currentThread().getState());
        }
    }
}

// 以上程序执行结果为：
// TestThread 的 start() 方法之前，主线程状态：RUNNABLE
// TestThread 的 run() 方法执行中，主线程状态：WAITING
// #1: 2
// #1: 1
// TestThread 执行完成，主线程状态：RUNNABLE
// TestThread 的 start() 方法之前，主线程状态：RUNNABLE
// TestThread 的 run() 方法执行中，主线程状态：WAITING
// #2: 2
// #2: 1
// TestThread 执行完成，主线程状态：RUNNABLE

interrupt() 方法：

public void interrupt()

描述：

该方法可以中断一个正在运行的线程。若是该线程处于某种阻塞时被调用中断方法中断，那么并不是将该线程直接中断，而是中断其阻塞状态，这时通常会抛出中断异常，通知应用程序该线程的阻塞状态被打断。

参数：

无

返回值：

无

public class TestThread extends Thread {
    public void run() {
        try {
            sleep(50000);  // 延迟50秒
        } catch (InterruptedException e) {
            System.out.println(e.getMessage());
        }
    }

    public static void main(String[] args) throws Exception {
        Thread thread = new TestThread();
        thread.start();
        System.out.println("在50秒之内按任意键中断线程!");
        System.in.read();
        thread.interrupt();
        thread.join();
        System.out.println("线程已经退出!");
    }
}

// 以上程序执行结果为：
// 在50秒之内按任意键中断线程!
// 3
// sleep interrupted
// 线程已经退出!

获取所有线程：

public class TestThread extends Thread {
    public static void main(String[] args) {
        TestThread t1 = new TestThread();
        t1.setName("thread1");
        t1.start();
        // 获取此线程所属的线程组
        ThreadGroup currentGroup = Thread.currentThread().getThreadGroup();
        // 返回此线程组及其子组中活动线程数的估计值(不准确)
        int noThreads = currentGroup.activeCount();
        Thread[] lstThreads = new Thread[noThreads];
        // 将此线程组及其子组中的每个活动线程复制到指定的数组中
        currentGroup.enumerate(lstThreads);
        for (int i = 0; i < noThreads; i++) {
            System.out.println("线程号：" + i + " = " + lstThreads[i].getName());
        }
    }
}

// 以上程序执行结果为：
// 线程号：0 = main
// 线程号：1 = Monitor Ctrl-Break
// 线程号：2 = thread1

// 以上程序执行结果也可能为：
// 线程号：0 = main
// 线程号：1 = Monitor Ctrl-Break

getPriority() 方法：

public final int getPriority()

描述：

获取此线程的优先级。

参数：

无

返回值：

返回此线程的优先级。

public class TestThread  {
    /**
     * 创建 Runnable 实例
     * @return Runnable 实例
     */
    private static Runnable makeRunnable() {
        // 使用内部类的一种简写向上转型创建 Runnable 实例
        Runnable r = new Runnable() {
            public void run() {
                for (int i = 0; i < 5; i++) {
                    Thread t = Thread.currentThread();
                    System.out.println("在 run() 方法中 - priority = "
                            + t.getPriority()+ ", name = " + t.getName());
                    try {
                        Thread.sleep(2000);
                    }
                    catch (InterruptedException x) {
                    }
                }
            }
        };
        return r;
    }

    public static void main(String[] args) {
        System.out.println("在 main() 方法中 - Thread.currentThread().getPriority() = " + Thread.currentThread().getPriority());
        System.out.println("在 main() 方法中 - Thread.currentThread().getName() = "+ Thread.currentThread().getName());
        Thread threadA = new Thread(makeRunnable(), "threadA");
        threadA.setPriority(Thread.MAX_PRIORITY);
        threadA.start();
        try {
            Thread.sleep(3000);
        }
        catch (InterruptedException x) {
        }
        System.out.println("在 main() 方法中 - threadA.getPriority() = "+ threadA.getPriority());
    }
}

// 以上程序执行结果为：
// 在 main() 方法中 - Thread.currentThread().getPriority() = 5
// 在 main() 方法中 - Thread.currentThread().getName() = main
// 在 run() 方法中 - priority = 10, name = threadA
// 在 run() 方法中 - priority = 10, name = threadA
// 在 main() 方法中 - threadA.getPriority() = 10
// 在 run() 方法中 - priority = 10, name = threadA
// 在 run() 方法中 - priority = 10, name = threadA
// 在 run() 方法中 - priority = 10, name = threadA

2018-10-16
Java编程思想 1～12 java多线程编程核心技术 23～57
线程(Thread)
Java 多线程编程 Java 给多线程编程提供了内置的支持。一个多线程程序包含两个或多个能并发运行的部分。程序的...
史上最全Java多线程面试题及答案
多线程并发编程是Java编程中重要的一块内容，也是面试重点覆盖区域。所以，学好多线程并发编程对Java程序员来来说...
Java多线程高级特性（JDK8）
[TOC] 一、Java多线程 1.Java多线程基础知识 Java 给多线程编程提供了内置的支持。一条线程指的是...
Java多线程学习：Future、Callable
Java多线程编程：Callable、Future和FutureTask浅析（多线程编程之四）最近在写清结算文件...
Java多线程
Java 多线程编程Java 给多线程编程提供了内置的支持。一个多线程程序包含两个或多个能并发运行的部分。程序的每...
Java多线程
Java 多线程编程 Java给多线程编程提供了内置的支持。一个多线程程序包含两个或多个能并发运行的部分。程序的每...
使用JDK自带的工具jstack找出造成运行程序死锁的原因
Java多线程编程也是Java面试中经常考察的内容。刚接触Java多线程编程的朋友们，可能会不慎写出一些会导致死锁...
Java多线程编程核心技术【笔记】
Java多线程编程核心技术【笔记】第一章 Java多线程技能使用多线程的场景？阻塞多线程提高运行效率依赖...
Java架构师阅读书单
一、内功心法 Java基础：《Java核心技术》《Java编程思想》《Effective Java》多线程...

Java的多线程编程

一个线程的生命周期

线程的优先级

创建一个线程的方法

线程的几个主要概念

死锁及解决方法

生产者/消费者问题

多线程的使用

线程池

相关文章

2018-10-16

线程(Thread)

史上最全Java多线程面试题及答案

Java多线程高级特性（JDK8）

Java多线程学习：Future、Callable

Java多线程

Java多线程

使用JDK自带的工具jstack找出造成运行程序死锁的原因

Java多线程编程核心技术【笔记】

Java架构师阅读书单

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读