题目要求：创建三个线程，每个线程分别打印ABC，并按照ABC的顺序执行十次

题目可以使用多种不同的方式解决，下面我们分别使用 Condition 等待唤醒机制、Semaphore 信号量、CountDownLatch 闭锁、Thread.join() 方法四种方式实现题目要求。

一、使用一个 ReentrantLock 和 三个 Condition 来实现：

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 题目要求：ABC三个线程顺序执行10次
 * 实现思路：使用一个ReentrantLock 和 三个 Condition 来实现
 */
public class PrintABCUsingCondition
{
    private static ReentrantLock lock = new ReentrantLock();
    private static Condition conditionA = lock.newCondition();
    private static Condition conditionB = lock.newCondition();
    private static Condition conditionC = lock.newCondition();

    public void execute(String flag)
    {
        lock.lock();

        for (int i = 1 ; i <= 10 ; i++){
            if ("A".equals(flag)) print(flag, conditionA, conditionB);
            if ("B".equals(flag)) print(flag, conditionB, conditionC);
            if ("C".equals(flag)) print(flag, conditionC, conditionA);
        }

        lock.unlock();
    }

    private void print(String name, Condition currentThread, Condition nextThread)
    {
        try{
            System.out.println(Thread.currentThread().getName()  + "-" + name);
            nextThread.signal();
            currentThread.await();
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws InterruptedException
    {
        PrintABCUsingCondition myTask = new PrintABCUsingCondition();

        new Thread(() -> myTask.execute("A")).start();
        //必须确保线程A比另外两个线程先拿到ReentrantLock，所以让主线程sleep一段时间
        Thread.sleep(500);
        new Thread(() -> myTask.execute("B")).start();
        new Thread(() -> myTask.execute("C")).start();
    }
}

二、基于 Semaphore 信号量来实现：

import java.util.concurrent.Semaphore;

/**
 * 题目要求：ABC三个线程顺序执行10次
 * 实现思路：使用一个Semaphore信号量来实现
 */
class PrintABCUsingSemaphore
{
    private Semaphore semaphoreA = new Semaphore(1);
    private Semaphore semaphoreB = new Semaphore(0);
    private Semaphore semaphoreC = new Semaphore(0);

    private void printA(){
        print("A", semaphoreA, semaphoreB);
    }

    private void printB(){
        print("B", semaphoreB, semaphoreC);
    }

    private void printC(){
        print("C", semaphoreC, semaphoreA);
    }

    private void print(String name, Semaphore currentSemaphore, Semaphore nextSemaphore)
    {
        for (int i = 0; i < 10; i++){
            try {
                currentSemaphore.acquire();
                System.out.println(Thread.currentThread().getName() +" print "+ name);
                nextSemaphore.release();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args)
    {
        PrintABCUsingSemaphore printABC = new PrintABCUsingSemaphore();
        new Thread(() -> printABC.printA()).start();
        new Thread(() -> printABC.printB()).start();
        new Thread(() -> printABC.printC()).start();
    }
}

三、基于 CountDownLatch 闭锁来实现：

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.*;

/**
 *  题目要求：ABC三个线程顺序执行10次
 *  实现思路：使用 CountDownLatch 来实现：
 * （1）定义dependLatch(所依赖的latch名)、selfLatch(自己的latch名)
 * （2）首先调用所依赖的latch的await()方法，如果所依赖的latch的count为0，则重置所依赖的latch并打印需要输出的，最后将自身的count减去
 * （3）sum为需要执行的次数
 */
public class PrintABCUsingCountDownLatch implements Runnable {

    private static Map<String, CountDownLatch> countDownLatchMap = new HashMap<>();

    private String dependLatch;
    private String selfLatch;

    private PrintABCUsingCountDownLatch(String dependLatch, String selfLatch)
    {
        this.dependLatch = dependLatch;
        this.selfLatch = selfLatch;
    }

    @Override
    public void run()
    {
        for (int i = 0; i < 10; i++)
        {
            try {
                countDownLatchMap.get(dependLatch).await();
                countDownLatchMap.put(dependLatch, new CountDownLatch(1));

                System.out.println(Thread.currentThread().getName() + ":" + selfLatch);

                countDownLatchMap.get(selfLatch).countDown();
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args)
    {
        String latchA = "A";
        String latchB = "B";
        String latchC = "C";

        countDownLatchMap.put(latchA, new CountDownLatch(1));
        countDownLatchMap.put(latchB, new CountDownLatch(1));
        countDownLatchMap.put(latchC, new CountDownLatch(1));

        //创建三个线程，但是此时由于三个CountDownLatch都不为0，所以三个线程都处于阻塞状态
        Thread threadA = new Thread(new PrintABCUsingCountDownLatch(latchC, latchA));
        Thread threadB = new Thread(new PrintABCUsingCountDownLatch(latchA, latchB));
        Thread threadC = new Thread(new PrintABCUsingCountDownLatch(latchB, latchC));
        threadA.start();
        threadB.start();
        threadC.start();
        //latchC 阻塞了 latchA；调用latchC的countDown()方法，先让latchC为0，使latchA先运行
        countDownLatchMap.get(latchC).countDown();
    }

四、 使用 Thread.join() 方法来实现：

/**
 * 题目要求：ABC三个线程顺序执行10次
 * 实现思路：使用 Thread.join() 方法来实现
 */
public class PrintABCUsingJoin
{
    public static void main(String[] args)
    {
        Thread t0 = new Thread(new Work((null)));
        Thread t1 = new Thread(new Work((t0)));
        Thread t2 = new Thread(new Work((t1)));
        t0.start();
        t1.start();
        t2.start();
    }
}

class Work implements Runnable
{
    private Thread beforeThread;
    public Work(Thread beforeThread)
    {
        this.beforeThread = beforeThread;
    }

    @Override
    public void run()
    {
        //调用前面线程的join方法
        if(beforeThread != null)
        {
            try{
                beforeThread.join();
            }catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println("当前线程：" + Thread.currentThread().getName());
    }
}

同一个线程对象能否多次调用start方法，搞清楚这个问题，首先需要了解线程的生命周期

一、线程生命周期

更多线程状态细节描述可查看Thread内部枚举类：State
从上图线程状态转换图可以看出：

1. 新建（NEW）状态是无法通过其他状态转换而来的;
2. 终止（TERMINATED）状态无法转为其他状态。

为何新建状态和终止状态不可逆转，接下来将通过Thread源码来分析

二、先通过一个正常程序来了解线程的执行过程：

public static void main(String[] args) {
    //创建一个线程t1
    Thread t1 = new Thread(() -> {
        try {
            //睡眠10秒，防止run方法执行过快，线程组被销毁
            TimeUnit.SECONDS.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    });
    //第一次启动
    t1.start();
}

1. 当执行new Thread时，Thread构造方法会调用内部init方法做一些初始化工作，如设置线程组、目标方法、线程名称、堆栈大小、线程优先级等，线程状态是由volatile关键字修饰的threadStatus控制的，初始值为0，即0表示新建状态（NEW）；
2. 调用t1.start方法后，该方法会将调用本地方法start0，start0会创建一个新线程并修改Thread.threadStatus的值；

扩展：了解Java线程的start方法如何回调run方法

下面看下start方法源码：

/**线程成员变量，默认为0，volatile修饰可以保证线程间可见性*/
private volatile int threadStatus = 0;
/* 当前线程所属的线程组 */
private ThreadGroup group;
/**
 * 同步方法，同一时间，只能有一个线程可以调用此方法
 */
public synchronized void start() {
    //threadStatus
    if (threadStatus != 0)
        throw new IllegalThreadStateException();
    //线程组
    group.add(this);
    boolean started = false;
    try {
        //本地方法，该方法会实际调用run方法
        start0();
        started = true;
    } finally {
        try {
            if (!started) {
                //创建失败，则从线程组中删除该线程
                group.threadStartFailed(this);
            }
        } catch (Throwable ignore) {
            /* start0抛出的异常不用处理，将会在堆栈中传递 */
        }
    }
}

1. 通过断点跟踪，可以看到当线程对象第一次调用start方法时会进入同步方法，会判断threadStatus是否为0，如果为0，则进行往下走，否则抛出非法状态异常；
2. 将当前线程对象加入线程组；
3. 调用本地方法start0执行真正的创建线程工作，并调用run方法，可以看到在start0执行完后，threadStatus的值发生了改变，不再为0；
4. finally块用于捕捉start0方法调用发生的异常。

扩展：线程是如何根据threadStatus来判断线程的状态的呢？
通过查看Thread提供的public方法getState可以看到，调用的是sun.misc.VM.toThreadState(threadStatus)，根据位运算得出线程的不同状态：

public static State toThreadState(int var0) {
        if ((var0 & 4) != 0) {
            return State.RUNNABLE;
        } else if ((var0 & 1024) != 0) {
            return State.BLOCKED;
        } else if ((var0 & 16) != 0) {
            return State.WAITING;
        } else if ((var0 & 32) != 0) {
            return State.TIMED_WAITING;
        } else if ((var0 & 2) != 0) {
            return State.TERMINATED;
        } else {
            return (var0 & 1) == 0 ? State.NEW : State.RUNNABLE;
        }
    }

继续回到原话题，当start调用后，并且run方法内容执行完后，线程是如何终止的呢？实际上是由虚拟机调用Thread中的exit方法来进行资源清理并终止线程的，看下exit方法源码：

/**
 * 系统调用该方法用于在线程实际退出之前释放资源
 */
private void exit() {
    //释放线程组资源
    if (group != null) {
        group.threadTerminated(this);
        group = null;
    }
    //清理run方法实例对象
    target = null;
    /*加速资源释放。快速垃圾回收 */
    threadLocals = null;
    inheritableThreadLocals = null;
    inheritedAccessControlContext = null;
    blocker = null;
    uncaughtExceptionHandler = null;
}

1. 到这里，t1 线程经历了从新建（NEW），就绪（RUNNABLE），运行（RUNNING），定时等待（TIMED_WAITING），终止（TERMINATED）这样一个过程；
2. 由于在第一次 start 方法后，threadStatus 值被改变，因此第二次调用start时会抛出非法状态异常；
3. 在调用start0方法后，如果run方法体内容被快速执行完，那么系统会自动调用exit方法释放资源，销毁对象，所以第二次调用start方法时，有可能内部资源已经被释放。

初步结论：同一个线程对象不可以多次调用 start 方法。

三、通过反射修改threadStatus来多次执行start方法

：

public static void main(String[] args) throws Exception {
    //创建一个线程t1
    Thread t1 = new Thread(() -> {
        try {
            //睡眠10秒，防止run方法执行过快，
            //触发exit方法导致线程组被销毁
            TimeUnit.SECONDS.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    });

    //第一次启动
    t1.start();

    //修改threadStatus，重新设置为0，即 NEW 状态
    Field threadStatus = t1.getClass().getDeclaredField("threadStatus");
    threadStatus.setAccessible(true);
    //重新将线程状态设置为0，新建（NEW）状态
    threadStatus.set(t1, 0);

    //第二次启动
    t1.start();
}

截取start后半截源码：

boolean started = false;
try {
    //第二次执行start0会抛异常，这时started仍然为false
    start0();
    started = true;
} finally {
    try {
        if (!started) {
            //创建失败，则从线程组中删除该线程
            group.threadStartFailed(this);
        }
    } catch (Throwable ignore) {
        /* start0抛出的异常不用处理，将会在堆栈中传递 */
    }
}

1. 在上面代码中，在第一次调用start方法后，我通过反射修改threadStatus值，这样在第二次调用时可以跳过状态值判断语句，达到多次调用start方法；
2. 当我第二次调用t1.start时，需要设置run方法运行时间长一点，防止系统调用exit方法清理线程资源；
3. 经过以上两步，我成功绕开 threadStatus 判断和线程组增加方法，开始执行start0方法，但是在执行start0的时候抛出异常，并走到了finally块中，由于start为false，所以会执行group.threadStartFailed(this)操作，将该线程从线程组中移除；
4. 所以start0中还是会对当前线程状态进行了一个判断，不允许重复创建线程。

最后结论：无论是直接二次调用还是通过反射二次调用，同一个线程对象都无法多次调用start方法，仅可调用一次。

参考：麦田-了解Java线程的start方法如何回调run方法

一、概念区分

1、并行与并发

并行

​ 当系统有一个以上CPU时，同一时刻，当一个CPU在执行一个任务时，另一个CPU在执行另一个任务，两个任务互不抢占CPU资源，可以同时进行（多核CPU，一个CPU执行一个进程）

并发

​ 一个CPU，同一时间，有多个任务在执行。但并发不是真正意义上的“同时进行”，只是将CPU划分成好几个时间片段，每个片段内执行一个任务，然后在这几个片段之间来回切换，由于CPU处理速度快，让用户感觉像是多个任务在同时执行。

区别：

• 并行是某一时刻，真正有多个程序在运行；并发是在一段时间内，宏观上多个程序同时运行。

• 并发，指多个事情，在同一时间段内同时发生了；多个任务之间是相互抢占资源的

  并行，指多个事情，在同一时间点上同时发生了；多个任务之间是不相互抢占资源的

• 只有在多个CPU或CPU多核时，才会发生并行，否则看似同时发生的事情，都是并发的

2、进程与线程

进程

​ 指系统中正在运行的一个应用程序；是资源分配的最小单位

线程

​ 是进程内独立执行的一个单一顺序的控制流；是系统分配处理器时间资源的基本单位；是程序执行的最小单位

区别

• 进程之间数据不共享
• 线程之间可以共享资源

二、线程的生命周期

​ 生命周期：在程序开发中，一个对象从被实例化完成，到这个对象使用结束并销毁的整个过程，类似于人的一生

​ 线程的生命周期：一个线程被实例化，到这个线程销毁的整个过程

线程的状态

• 新建：New

​ 一个线程被实例化完成，但是还没有做任何动作

• 就绪：Ready

​ 一个线程已经被启动 (调用start()方法)，开始争抢CPU的时间片

• 运行：Run

​ 一个线程抢到了CPU的时间片，开始执行这个线程中的逻辑

• 阻塞：Interrupt

​ 一个线程在运行的过程中，受到某些操作的影响，放弃已经获取的CPU时间片，并且不再参与CPU时间片的争抢，此时线程处于挂起状态

• 死亡：Dead

​ 一个线程对象需要被销毁

三、开启线程的方式

1、继承Thread类，实现其run()方法

//要自定义一个线程类，并且该类要继承Thread类
class MyThread extends Thread{
	//重写run方法
	@Override
	public void run() {
		for(int i=0;i<5;i++) {
			System.out.println("子线程逻辑："+i);
		}
	}
}
public class ThreadClass {
	public static void main(String[] args) {
		MyThread mt=new MyThread();  //新建
		mt.start();    //就绪
		System.out.println("主线程逻辑执行结束");
	}
}
/*输出结果：
主线程逻辑执行结束
子线程逻辑：0
子线程逻辑：1
子线程逻辑：2
子线程逻辑：3
子线程逻辑：4
*/

如果是串行运行，则“主线程逻辑执行结束”这句话应该最后执行。但由于并发执行的多线程存在，使得主程序逻辑先执行完毕，在执行子线程

注意：只有调用start方法才会启动线程，并且使该线程执行run方法；如果直接调用run方法，则并没有开启线程，即线程不会进入就绪状态。

2、实现Runnable接口，实现其run()方法

/*
 * Runnable接口是一个函数式接口，可以采用Lambda表达式实现其run方法
 */
public class ThreadClass {
	public static void main(String[] args) {
		Runnable r1=()->{
			for(int i=0;i<5;i++) {
				System.out.println("子线程中的逻辑："+i);
			}
		};
		Thread t=new Thread(r1);  //新建
		t.start();    //就绪
		System.out.println("主线程逻辑执行结束");
	}
}
//输出结果同上

3、实现Callable接口

与Runnable接口类似，只是该方式有返回值，但Runnable没有返回值

需要使用一个中介FutureTask

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

public class Test {
	public static void main(String[] args) {
		//返回值是int类型
		Callable callable=()->{
			int result=0;
			for(int i=0;i<100;i++) {
				result+=i;
			}
			return result;
		};
		//Thread thread=new Thread(callable); 不能直接像创建Runnable接口一样
		//知道返回值是int性。使用泛型约束
		FutureTask<Integer> task=new FutureTask<> (callable);
		
		Thread thread=new Thread(task);
		thread.start();
		
		//获取计算结果
		Integer integer = null;
		try {
			integer = task.get();  //该方法会抛出两个异常，需要手动处理
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (ExecutionException e) {
			e.printStackTrace();
		}  
		System.out.println(integer);
	}
}

4、异同点

• 继承Thread类，可读性更高，但是如果某个类类继承了Thread类，那么该类将不能再继承其他类，这有可能会破坏原有的继承结构
• 使用Runnable接口，程序可对象降低，但不会破坏继承结构，一般多使用这种方式

四、线程的常用方法

1、线程的命名setName

• 实例化一个线程，使用setName()方法
• 实例化一个线程的同时，通过构造方法对线程进行命名
• 3、使用用户自定义的线程类，在实例化的同时，进行名字的赋值
  需要给自定义线程类添加对应的构造方法

class MyThread extends Thread{
	public MyThread() {}
	public MyThread(String name) {
		this.setName(name);     //使用setName()方法
		//super(name);  //直接调用父类的构造方法
	}
}
public class ThreadClass {
	public static void main(String[] args) {
		//1、实例化一个线程，使用setName()方法
		Thread t=new Thread();
		t.setName("用户线程1");
		System.out.println(t.getName());

		//2、实例化一个线程的同时，通过构造方法对线程进行命名
		//  构造方法：Thread(Runnable r,String name);
		Thread t2=new Thread(()->{},"用户线程2"); 
		System.out.println(t2.getName());
		
		//3、使用用户自定义的线程类，在实例化的同时，进行名字的赋值
		//   需要给自定义线程类添加对应的构造方法
		MyThread t3=new MyThread("用户线程3");
		System.out.println(t3.getName());
	}
}

2、线程休眠sleep（Run->Interrupt）

1. 调用**sleep()**方法，参数：以毫秒为单位的时间差
2. 会抛出InterruptedException异常，需要处理
3. 使得线程由运行状态变为阻塞状态，当休眠时间到达时，才会重新变为就绪状态。即使此时系统中没有其他可执行的线程，处于sleep的线程也依然不会执行

class MyThread extends Thread{
	//重写run方法
	@Override
	public void run() {
		for(int i=0;i<5;i++) {
			System.out.println(+i);
			//线程休眠
			//参数：以毫秒为单位
			//需要捕获异常
			try {
				Thread.sleep(1000);  //休眠1秒
			} 
			catch (InterruptedException e) {
				e.printStackTrace();
			}   
		}
	}
}
public class ThreadClass {
	public static void main(String[] args) {
		//调用threadSleep方法
		threadSleep();
	}
    /****线程休眠****/
	public static void threadSleep() {
		//实例化一个线程
		MyThread mt=new MyThread();
		mt.start();
	}
}
//输出形式：每隔1秒输出一个i值

3、线程的优先级setPriority

1. 调用**setPriority()**方法，参数：[0,10]范围内的一个整数，默认是5
2. 设置优先级，只是设置这个线程可以抢到CPU时间片的概率，并不是优先级高的线程一定能抢到CPU时间片（不是优先级高的线程一定先执行，也不是优先级高的线程执行完再执行其他线程）
3. 设置优先级必须要放在线程开始（start）之前

public class ThreadClass {
	public static void main(String[] args) {
		threadPriority();
	}
    /****设置线程的优先级***/
	public static void threadPriority() {
		Runnable r=()->{
			for(int i=0;i<5;i++){
					System.out.println(Thread.currentThread().getName()+":"+i);
			}
		};
        //1、线程实例化
		Thread t1=new Thread(r,"Thread-1");
		Thread t2=new Thread(r,"Thread-2");
		
		//2、设置优先级, 必须要将该操作放在线程开始（start）之前
		t1.setPriority(10);
		t2.setPriority(1);
		
        //3、线程启动
		t1.start();
		t2.start();
	}
}
//输出结果：交替执行

4、线程的礼让yield（Run->Ready）

1. 调用**yield()**方法，类方法
2. 线程礼让是指让当前运行的线程释放自己的CPU资源，由运行状态，回到就绪状态。**但并不意味着一定去执行另一个线程，**此时依然是两个线程进行CPU时间片的抢夺

public class ThreadClass {
	public static void main(String[] args) {
		threadYield();
	}
	/***线程的礼让***/
	public static void threadYield() {
		Runnable r=()->{
			for(int i=0;i<10;i++) {
				System.out.println(Thread.currentThread().getName()+":"+i);
				//线程礼让
				if(i==3) {
					Thread.yield();
				}
			}
		};
		Thread t1=new Thread(r,"Thread-1");
		Thread t2=new Thread(r,"Thread-2");
		
		t1.start();
		t2.start();
	}
}
/*输出结果：
Thread-2:0
Thread-2:1
Thread-2:2
Thread-2:3   //Thread-2礼让，CPU被Thread-1抢到
Thread-1:0
Thread-1:1
Thread-1:2
Thread-1:3  //Thread-1礼让，但是CPU还是被Thread-1抢到，Thread-1继续执行
Thread-1:4
Thread-1:5
Thread-1:6
Thread-1:7
Thread-1:8
Thread-1:9   //Thread-1执行完毕，Thread-2接着执行
Thread-2:4
Thread-2:5
Thread-2:6
Thread-2:7
Thread-2:8
Thread-2:9
*/

5、线程合并join

1. 执行join的线程，在该过程中，其他线程阻塞，待此线程执行完毕，再执行其他线程。（插队）
2. 抛出InterruptException异常

public class JoinTest {

	public static void main(String[] args) {
		Runnable runnable=()->{
			for(int i=0;i<100;i++) {
				System.out.println("vip线程"+i);
			}
		};
		
		Thread thread=new Thread(runnable);
		thread.start();
		//主线程输出100次
		for(int i=0;i<100;i++) {
			/*
			 * 当主线程运行到第50次时，调用join方法，那么此时会等join方法加入的线程执行完毕，在执行主线程
			 * */
			if(i==50) {
				try {
					thread.join();
				} 
				catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			System.out.println("main"+i);
		}
	}
}
/*输出：在50之前，主线程和子线程交替执行，但是等到主线程为50时，此时子线程会执行直到100结束，然后主线程才执行
*/

6、守护线程setDaemon

1. 如果所有的用户线程结束，那么守护线程会自动死亡；虚拟机不需要等待守护线程执行结束
2. setDaemon默认是false，如果要设置一个线程为守护线程，则改为true即可

public class DaemonTest {
	public static void main(String[] args) {
		Runnable r1=()->{
			while(true) {
				System.out.println("守护线程");
			}
		};
		
		for(int i=0;i<10;i++) {
			System.out.println("主线程"+i);
		}
		
		Thread thread=new Thread(r1);
		thread.setDaemon(true);  //默认是false，表示用户线程
		thread.start();
	}
}
//守护线程是一个死循环，但是等待主线程执行结束后，该线程会自动停止

五、线程安全问题

临界资源：多个线程共享的资源。当多个线程同时去访问这个共享资源时，会出现线程安全问题

1、产生的原因

当一个线程在访问并操作某个资源的过程中，还没来得及完全修改该资源，CPU时间片就被其他线程抢走

//用四个线程模拟四个售票员卖票，仓库中的余票即为临界资源
class TicketCenter{
	//描述剩余票的数量
	public static int restCount=100;
}
public class SourseProblem {
	public static void main(String[] args) {
		Runnable r=()->{
			//当余票大于0时，可以继续售票
			while(TicketCenter.restCount>0) {
				System.out.println(Thread.currentThread().getName()+"卖出一张票，剩余"+ --TicketCenter.restCount+"张");
			}
		};
		//四个线程模拟四个售票员，线程名模拟售票员名
		Thread t1=new Thread(r,"Thread-1");
		Thread t2=new Thread(r,"Thread-2");
		Thread t3=new Thread(r,"Thread-3");
		Thread t4=new Thread(r,"Thread-4");
		
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}

输出结果：

出现临界资源问题，这是因为一个线程在计算余票的过程中，还没来的及将计算、或计算后的结果还没来得及赋给restCount，CPU就被其他线程抢走，此时其他线程中的余票是当前抢到时刻的余票值。

2、解决方法

• JVM实现的synchronized
• JDK实现的ReentrantLock

方式一：使用同步代码块

用synchronized修饰多线程需要访问的代码

class TicketCenter{
	//描述剩余票的数量
	public static int restCount=100;
}
public class SourseProblem {
	public static void main(String[] args) {
		Runnable r=()->{
			//当余票大于0时，可以继续售票
			while(TicketCenter.restCount>0) {
				//同步监视器
				synchronized("") {
					if(TicketCenter.restCount<=0) {
						return;
					}
					System.out.println(Thread.currentThread().getName()+"卖出一张票，剩余"+ --TicketCenter.restCount+"张");
				}
			}
		};
		//四个线程模拟四个售票员，线程名模拟售票员名
		Thread t1=new Thread(r,"Thread-1");
		Thread t2=new Thread(r,"Thread-2");
		Thread t3=new Thread(r,"Thread-3");
		Thread t4=new Thread(r,"Thread-4");
		
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}

方法二：同步方法：使用关键字synchronized修饰的方法

将上面的同步代码段用一个方法实现

1. 静态方法：同步监视器就是：当前类.class
2. 非静态方法：同步监视器是 this

class TicketCenter{
	//描述剩余票的数量
	public static int restCount=100;
}
public class SourseProblem {
	public static void main(String[] args) {
		Runnable r=()->{
			while(TicketCenter.restCount>0) {
				soldTicket();
			}
		};
		Thread t1=new Thread(r,"Thread-1");
		Thread t2=new Thread(r,"Thread-2");
		Thread t3=new Thread(r,"Thread-3");
		Thread t4=new Thread(r,"Thread-4");
	
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
	//同步方法
	public synchronized static void soldTicket(){
		if(TicketCenter.restCount<=0) {
			return;
		}
		System.out.println(Thread.currentThread().getName()+"卖出一张票，剩余"+ --TicketCenter.restCount+"张");
	}
}

方式三：同步锁

显式定义同步锁对象来实现同步

class TicketCenter{
	//描述剩余票的数量
	public static int restCount=100;
}
public class SourseProblem {
	public static void main(String[] args) {
		//实例化一个锁对象
		ReentrantLock rt=new ReentrantLock();
		
		Runnable r=()->{
			while(TicketCenter.restCount>0) {
				//对临界资源上锁
				rt.lock();
				
				if(TicketCenter.restCount<=0) {
					return;
				}
				System.out.println(Thread.currentThread().getName()+"卖出一张票，剩余"+ --TicketCenter.restCount+"张");
				
				//对临界资源解锁
				rt.unlock();
			}
		};
		Thread t1=new Thread(r,"Thread-1");
		Thread t2=new Thread(r,"Thread-2");
		Thread t3=new Thread(r,"Thread-3");
		Thread t4=new Thread(r,"Thread-4");
		
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}

3、死锁

多个线程彼此持有对方所需要的锁，而不释放自己的锁

//线程A、B互相等待对方释放拥有的锁
public class DeadLock {
	public static void main(String[] args) {
        
		Runnable runnable1=()->{
			synchronized("A"){
				System.out.println("A线程持有了A锁，等待B锁");
				//此时A线程已经持有A锁了，让它继续持有B锁
                /*为了确保产生死锁
                try {
					Thread.sleep(1000);
				} 
				catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}*/
                
				synchronized("B"){
					System.out.println("A线程持有了A锁和B锁");
				}
			}
		};
		
		Runnable runnable2=()->{
			synchronized("B"){
				System.out.println("B线程持有了B锁，等待A锁");
				//此时B线程已经持有B锁了，让它继续去持有A锁
				synchronized("A"){
					System.out.println("B线程持有了A锁和B锁");
				}
			}
		};
		
		Thread t1=new Thread(runnable1);
		Thread t2=new Thread(runnable2);
		
		t1.start();
		t2.start();
	}
}
/*输出结果：
B线程持有了B锁，等待A锁
A线程持有了A锁，等待B锁
(程序未结束)
*/

上述代码其实不能完全产生死锁，如果在A线程获取B锁之前，B线程都没有获得执行机会，那么B线程就不会获取到B锁，此时程序依然会执行，不会产生死锁。为了一定产生死锁情况，可以在A线程执行过程中调用一个sleep方法。

4、线程通信：解决死锁的办法

方式1：synchronized下的通信

• wait()：等待，当前的线程释放对同步监视器的锁定，并且让出CPU资源，使得当前的线程进入等待队列中
• notify()：通知，唤醒在此同步监视器上等待的一个线程（具体哪一个由CPU决定），使这个线程进入锁池
• notifyAll()：通知，唤醒在此同步监视器上等待的所有线程，使这些线程进入锁池

public class DeadLock {
	public static void main(String[] args) {
        
		Runnable runnable1=()->{
			synchronized("A"){
				System.out.println("A线程持有了A锁，等待B锁");
				//A线程释放A锁(捕获异常)
				try {
					"A".wait();
				} 
				catch (InterruptedException e) {
					e.printStackTrace();
				}
				
				synchronized("B"){
					System.out.println("A线程持有了A锁和B锁");
				}
			}
		};
		
		Runnable runnable2=()->{
			synchronized("B"){
				System.out.println("B线程持有了B锁，等待A锁");
				
				synchronized("A"){
					System.out.println("B线程持有了A锁和B锁");
					//此时B线程已经执行完成了，但是A线程任然还在等待，因此需要唤醒A线程
					"A".notify();
				}
			}
		};
		
		Thread t1=new Thread(runnable1);
		Thread t2=new Thread(runnable2);
		
		t1.start();
		t2.start();
	}
}
/*输出结果：
A线程持有了A锁，等待B锁
B线程持有了B锁，等待A锁
B线程持有了A锁和B锁
A线程持有了A锁和B锁
*/

方式2：Lock锁下的通信，采用Condition控制通信。JUC中的类（java.util.comcurrent类）

• await()：等价于wait()
• signal()：等价于notify()
• signalAll()：等价于notifyAll()

4、多线程下的单例类

懒汉式单例类会出现问题

//定义一个单例类
class Boss{
	//构造器私有化
	private Boss() {
		System.out.println("一个Boss对象被实例化了");
	}
	private static Boss instance=null;
	//外部类只能通过该方法获取Boss类的实例
	public static Boss getBoss() {
		if(instance==null) {
			instance=new Boss();
		}
		return instance;
	}
}
public class SingletonTest {
	public static void main(String[] args) {
		Runnable runnable=()->{
			Boss.getBoss();
		};
		//开辟了100条线程去获取这Boss实例
		for(int i=0;i<100;i++) {
			new Thread(runnable).start();
		}
	}
}

当多线程去执行这个单例类时，还是希望只产生一个实例对象，但程序输出结果明显不是，这是由于多线程导致的。

修改方式1：对临界资源上锁，使用同步代码

//定义一个单例类
class Boss{
	//构造器私有化
	private Boss() {
		System.out.println("一个Boss对象被实例化了");
	}
	private static Boss instance=null;

	public static Boss getBoss() {
        //同步代码段
		synchronized("") {
			if(instance==null) {
				instance=new Boss();
			}
		}
		return instance;
	}

}

public class SingletonTest {
	public static void main(String[] args) {
		Runnable runnable=()->{
			Boss.getBoss();
		};
		//开辟了100条线程去获取这Boss实例
		for(int i=0;i<100;i++) {
			new Thread(runnable).start();
		}
	}
}

修改方式2：对临界资源上锁，使用同步方法

class Boss{
	//构造器私有化
	private Boss() {
		System.out.println("一个Boss对象被实例化了");
	}
	private static Boss instance=null;
	//同步方法
	public static synchronized Boss getBoss() {
		if(instance==null) {
			instance=new Boss();
		}
		return instance;
	}
}

public class SingletonTest {
	public static void main(String[] args) {
		Runnable runnable=()->{
			Boss.getBoss();
		};
		//开辟了100条线程去获取这Boss实例
		for(int i=0;i<100;i++) {
			new Thread(runnable).start();
		}
	}
}

六、线程池

线程池在系统启动时就创建大量空闲的线程。提前创建多个线程，放入线程池，使用时直接从线程池中获取，使用完放回池中

1、作用

可以避免频繁创建销毁线程的过程，实现充分利用

• corePoolSize:核心池的大小（可以放多少个线程）
• maximumPoolSize:最大线程数（一次可以同时运行的线程数量）
• keepAliveTime:线程没有任务时最多保持多长时间后会终止

2、创建方式

• ExecutorService接口：线程池真正的接口
• Executor：创建线程的工具类，调用该类的newFixedThreadPool(corePoolSizesize)方法来创建线程池
• execute：执行Runnable接口的，无返回值
• Future submit：执行Callable接口的，有返回值
• shutdown:关闭连接

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolTest {
	public static void main(String[] args) {
		Runnable r=()->{
			System.out.println(Thread.currentThread().getName());
		};
		//创建线程池，设置大小为10
		ExecutorService service=Executors.newFixedThreadPool(10);
		//执行
		service.execute(r);
		service.execute(r);
		service.execute(r);
		service.execute(r);
        //关闭连接
		service.shutdown();
	}
}
/*输出结果：
pool-1-thread-3
pool-1-thread-4
pool-1-thread-2
pool-1-thread-1
*/

七、JUC组件

1、未来任务FutureTask

利用Callable创建线程时，有返回值，该值由Future进行封装，FutureTask实现了RunnableFuture接口，而该接口继承自Runnable和Future接口，因此FutureTask既可以当做一个任务执行，也可以有返回值。

当计算一个任务需要很长时间时，可使用FutureTask来封装这个任务，使得主线程在完成自己的任务后在去获取这个计算结果

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

public class FutureTaskTest {
	public static void main(String[] args) {
		//创建一个Clallable接口，有返回值，给子线程执行
		Callable<Integer> cla=()->{
			int result=0;
			for(int i=0;i<100;i++) {
				Thread.sleep(10);  //每一次计算时都让让主线程执行一段时间
				result+=i;
			}
			return result;
		};
		//新建一个FutureTask实例
		FutureTask<Integer> futureTask=new FutureTask<>(cla);
		//执行计算任务的线程
		Thread t1=new Thread(futureTask);
		t1.start();
		
        //创建Runnable接口，给主线程执行
		Runnable runnable=()->{
			System.out.println("主线程任务正在执行");
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		};
		
		Thread t2=new Thread(runnable);
		t2.start();
		
		//得到有返回值的输出
		try {
			System.out.println(futureTask.get());
		} catch (InterruptedException | ExecutionException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}
/*输出结果：
另一个线程任务正在执行
4950
*/
//如果将Callable执行体中的Thread.sleep(10);去掉，则执行结果为：4950  另一个线程任务正在执行。

2、阻塞队列BlockingQueue

利用BlockingQueue作为线程同步的工具，主要用来实现消费者生产者设计模式。详见《生产者消费者设计模式》

3、叉链接ForkJoin

主要用于并行计算中，将大的任务分成小的任务进行计算，再把小任务的结果合并成总的计算结果