Java多线程详解
一、基本概念
程序(program)
是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。
进程(process)
进程是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期
如：运行中的QQ，运行中的MP3播放器
程序是静态的，进程是动态的
进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域
线程(thread)
进程可进一步细化为线程，是一个程序内部的一条执行路径。
若一个进程同一时间并行执行多个线程，就是支持多线程的
线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开
销小
一个进程中的多个线程共享相同的内存单元/内存地址空间它们从同一堆中分配对象，可以 访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资 源可能就会带来安全的隐患。
举一个简单的例子：
我们打开电脑上的360安全卫士，这个时候启动了一个进程（可以在任务管理器里查看），里面有很多功能：电脑体检、电脑杀毒、清理垃圾等，每一项就相当于一个线程，我们可以每一项同步地启动起来，这个时候，我们的360安全卫士就相当于是多线程的。
二、深入理解线程
进程可以细化为多个线程。
每个线程，拥有自己独立的结构：栈（虚拟机栈）、程序计数器（Program Counter Register）
多个线程，共享同一个进程中的结构：方法区、堆。
[外链图片转存失败(img-WRgTBtB6-1564310247749)(pic/1.jpg)]
三、并行和并发
1.单核CPU和多核CPU的理解
单核CPU，其实是一种假的多线程，因为在一个时间单元内，也只能执行一个线程的任务。
例如：虽然有多车道，但是收费站只有一个工作人员在收费，只有收了费才能通过，那么CPU就好比收费人员。如果有某个人不想交钱，那么收费人员可以 把他“挂起”（晾着他，等他想通了，准备好了钱，再去收费）。但是因为CPU时间单元特别短，因此感觉不出来。
如果是多核的话，才能更好的发挥多线程的效率。（现在的服务器都是多核的）
一个Java应用程序java.exe，其实至少有三个线程：main()主线程，gc() 垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。
2.并行和并发
并行：多个CPU同时执行多个任务，也就是同一时刻，有多条指令在多个处理器上同时执行。比如：多个人同时做不同的事。
并发：一个CPU(采用时间片)同时执行多个任务，也就是同一时刻只能有一条指令执行，但多个进程指令被快速轮换执行，使得宏观上有多个进程执行的效果。比如：秒杀、多个人做同一件事
四、创建线程的四种方法
方式一：继承Thread类的方式：
-
- 创建一个继承于Thread类的子类
-
- 重写Thread类的run() --> 将此线程执行的操作声明在run()中
-
- 创建Thread类的子类的对象
-
- 通过此对象调用start()：①启动当前线程 ② 调用当前线程的run()
示例：
public class MyThread extends Thread {
private int i;
public void run() {
for (; i < 10; i++) {
// 当线程类继承Thread类时，直接使用this获取当前线程
// Thread对象的getName()返回当前线程的名字
// 因此可以直接调用getName()方法返回当前线程的名字
System.out.println(getName() + " " + i);
}
}
public static void main(String[] args) {
MyThread my1 = new MyThread();
MyThread my2 = new MyThread();
my1.start();
my2.start();
}
}
输出：
Thread-0 0
Thread-0 1
Thread-1 0
Thread-1 1
Thread-1 2
Thread-0 2
Thread-0 3
Thread-0 4
Thread-1 3
Thread-0 5
Thread-1 4
Thread-1 5
Thread-0 6
Thread-1 6
Thread-0 7
Thread-1 7
Thread-0 8
Thread-1 8
Thread-0 9
Thread-1 9
方式二：实现Runnable接口的方式：
-
- 创建一个实现了Runnable接口的类
-
- 实现类去实现Runnable中的抽象方法：run()
-
- 创建实现类的对象
-
- 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
-
- 通过Thread类的对象调用start()
示例：
public class MyThread2 implements Runnable{
private int i;
@Override
public void run() {
for (; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + " " + i);
}
}
public static void main(String[] args) {
MyThread2 mt = new MyThread2();
new Thread(mt,"新线程1==========").start();
new Thread(mt,"新线程2----------").start();
}
}
输出：
新线程1========== 0
新线程2---------- 0
新线程1========== 1
新线程2---------- 2
新线程1========== 3
新线程2---------- 4
新线程1========== 5
新线程1========== 7
新线程2---------- 6
新线程1========== 8
新线程2---------- 9
注意：一个线程对象只能调用一次start()方法启动，如果重复调用了，则将抛出以上的异常"IllegalThreadStateException"。
方式三：实现Callable接口：
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/**
* 创建线程的方式三：实现Callable接口。 --- JDK 5.0新增
*
*
* 如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大？
* 1. call()可以有返回值的。
* 2. call()可以抛出异常，被外面的操作捕获，获取异常的信息
* 3. Callable是支持泛型的
*
*/
//1.创建一个实现Callable的实现类
class NumThread implements Callable{
//2.实现call方法，将此线程需要执行的操作声明在call()中
@Override
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 ThreadNew {
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()
new Thread(futureTask).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();
}
}
}
使用线程池
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
/**
* 创建线程的方式四：使用线程池
*
* 好处：
* 1.提高响应速度（减少了创建新线程的时间）
* 2.降低资源消耗（重复利用线程池中线程，不需要每次都创建）
* 3.便于线程管理
* corePoolSize：核心池的大小
* maximumPoolSize：最大线程数
* keepAliveTime：线程没有任务时最多保持多长时间后会终止
*/
class NumberThread implements Runnable{
@Override
public void run() {
for(int i = 0;i <= 100;i++){
if(i % 2 == 0){
System.out.println(Thread.currentThread().getName() + ": " + i);
}
}
}
}
class NumberThread1 implements Runnable{
@Override
public void run() {
for(int i = 0;i <= 100;i++){
if(i % 2 != 0){
System.out.println(Thread.currentThread().getName() + ": " + i);
}
}
}
}
public class ThreadPool {
public static void main(String[] args) {
//1. 提供指定线程数量的线程池
ExecutorService service = Executors.newFixedThreadPool(10);
ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
//设置线程池的属性
// System.out.println(service.getClass());
// service1.setCorePoolSize(15);
// service1.setKeepAliveTime();
//2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
service.execute(new NumberThread());//适合适用于Runnable
service.execute(new NumberThread1());//适合适用于Runnable
// service.submit(Callable callable);//适合使用于Callable
//3.关闭连接池
service.shutdown();
}
}
五、线程的生命周期
线程的生命周期经历通常要经历五个状态
新建：当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建 状态
就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源
运行：当就绪的线程被调度并获得CPU资源时,便进入运行状态， run()方法定义了线 程的操作和功能
阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行， 进入阻塞状态
死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束
六、守护线程
有一种线程，在后台运行的，它的任务是为其他线程提供服务，这种线程称为后台线程，又称为守护线程或精灵线程。JVM的垃圾回收线程就是典型的后台线程。
特征：如果所有的前台线程都死亡，后台线程会自动死亡
七、线程同步
线程安全问题：
- 多个线程在操作共享的数据。
- 操作共享数据的线程代码有多条。
有个经典的例子：银行取钱
假如我卡上有3000元，我去银行取2000元，银行需要判断你卡里有没有够2000元，如果够的话再给你钱，这个时候，如果你的同学A也有你的账号，在银行判断你卡里够不够2000元的时候，A也去银行取钱取2000元，这时候A看到的银行余额仍是3000元，那这样一来不就总计拿到了4000元了吗？好爽！
当然，银行是不会出现这样的纰漏的！
那么这个线程安全的问题仍然存在，该怎么解决呢？
解决线程安全的问题是使线程同步 ，我们有3种方法：
- 同步代码块
- 同步方法
- Lock
同步代码块
Java的多线程支持引入了同步监视器来解决这个问题，使用同步监视器的通用方法就是同步代码块。
同步代码块的语法格式如下：
synchronized(obj){
// 此处的代码就是同步代码块
}
括号里的obj就是同步监视器。同步监视器的目的是阻止两个线程对同一个共享资源进行并发访问。
上面代码的含义就是：线程开始执行同步代码块之前，必须先获得对同步监视器的锁定。
同步方法
与同步代码块对应，Java的多线程安全支持还提供了同步方法，同步方法就是使用synchronized关键字来修饰某个方法，这个方法称为同步方法。同步方法的同步监视器是this，也就是调用该方法的对象。
同步方法的语法格式如下：
修饰符 synchronized 方法返回值 methodName(){
}
Lock
通过显示定义同步锁对象来实现同步，比较常用的是ReentrantLock（可重入锁）。
private final ReentrantLock lock = new ReentrantLock();
public void m(){
lock.lock();
try{
// 需要保证线程安全的代码
}
// 使用finally来保证释放锁
finally{
lock.unlock();
}
}
八、线程通信
线程通信
这里我直接用一个例子演示一下线程通信
/**
* 线程通信的例子：使用两个线程打印 1-100。线程1, 线程2 交替打印
*
* 涉及到的三个方法：
* wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
* notify():一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的那个。
* notifyAll():一旦执行此方法，就会唤醒所有被wait的线程。
*
* 说明：
* 1.wait()，notify()，notifyAll()三个方法必须使用在同步代码块或同步方法中。
* 2.wait()，notify()，notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器。
* 否则，会出现IllegalMonitorStateException异常
* 3.wait()，notify()，notifyAll()三个方法是定义在java.lang.Object类中。
*
*/
class Number implements Runnable{
private int number = 1;
private Object obj = new Object();9
@Override
public void run() {
while(true){
synchronized (obj) {
obj.notify();
if(number <= 100){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ":" + number);
number++;
try {
//使得调用如下wait()方法的线程进入阻塞状态
obj.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}else{
break;
}
}
}
}
}
public class CommunicationTest {
public static void main(String[] args) {
Number number = new Number();
Thread t1 = new Thread(number);
Thread t2 = new Thread(number);
t1.setName("线程1");
t2.setName("线程2");
t1.start();
t2.start();
}
}
如果还不理解，我们再来研究一个经典的生产者/消费者问题
/**
* 线程通信的应用：经典例题：生产者/消费者问题
*
* 生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，
* 店员一次只能持有固定数量的产品(比如:20），如果生产者试图生产更多的产品，店员
* 会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品
* 了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。
*
* 分析：
* 1. 是否是多线程问题？是，生产者线程，消费者线程
* 2. 是否有共享数据？是，店员（或产品）
* 3. 如何解决线程的安全问题？同步机制,有三种方法
* 4. 是否涉及线程的通信？是
*
*/
class Clerk{
private int productCount = 0;
//生产产品
public synchronized void produceProduct() {
if(productCount < 20){
productCount++;
System.out.println(Thread.currentThread().getName() + ":开始生产第" + productCount + "个产品");
notify();
}else{
//等待
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
//消费产品
public synchronized void consumeProduct() {
if(productCount > 0){
System.out.println(Thread.currentThread().getName() + ":开始消费第" + productCount + "个产品");
productCount--;
notify();
}else{
//等待
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class Producer extends Thread{//生产者
private Clerk clerk;
public Producer(Clerk clerk) {
this.clerk = clerk;
}
@Override
public void run() {
System.out.println(getName() + ":开始生产产品.....");
while(true){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
clerk.produceProduct();
}
}
}
class Consumer extends Thread{//消费者
private Clerk clerk;
public Consumer(Clerk clerk) {
this.clerk = clerk;
}
@Override
public void run() {
System.out.println(getName() + ":开始消费产品.....");
while(true){
try {
Thread.sleep(20);
} catch (InterruptedException e) {
e.printStackTrace();
}
clerk.consumeProduct();
}
}
}
public class ProductTest {
public static void main(String[] args) {
Clerk clerk = new Clerk();
Producer p1 = new Producer(clerk);
p1.setName("生产者1");
Consumer c1 = new Consumer(clerk);
c1.setName("消费者1");
Consumer c2 = new Consumer(clerk);
c2.setName("消费者2");
p1.start();
c1.start();
c2.start();
}
}
九、死锁
当两个线程相互等待对方释放同步监视器时就会发生死锁。
下面看个经典实例：
class A {
public synchronized void foo(B b) {
System.out.println("当前线程名: " + Thread.currentThread().getName()
+ " 进入了A实例的foo方法"); // ①
try {
Thread.sleep(200);
} catch (InterruptedException ex) {
ex.printStackTrace();
}
System.out.println("当前线程名: " + Thread.currentThread().getName()
+ " 企图调用B实例的last方法"); // ③
b.last();
}
public synchronized void last() {
System.out.println("进入了A类的last方法内部");
}
}
class B {
public synchronized void bar(A a) {
System.out.println("当前线程名: " + Thread.currentThread().getName()
+ " 进入了B实例的bar方法"); // ②
try {
Thread.sleep(200);
} catch (InterruptedException ex) {
ex.printStackTrace();
}
System.out.println("当前线程名: " + Thread.currentThread().getName()
+ " 企图调用A实例的last方法"); // ④
a.last();
}
public synchronized void last() {
System.out.println("进入了B类的last方法内部");
}
}
public class DeadLock implements Runnable {
A a = new A();
B b = new B();
public void init() {
Thread.currentThread().setName("主线程");
// 调用a对象的foo方法
a.foo(b);
System.out.println("进入了主线程之后");
}
public void run() {
Thread.currentThread().setName("副线程");
// 调用b对象的bar方法
b.bar(a);
System.out.println("进入了副线程之后");
}
public static void main(String[] args) {
DeadLock dl = new DeadLock();
new Thread(dl).start();
dl.init();
}
}
输出：
当前线程名: 主线程 进入了A实例的foo方法
当前线程名: 副线程 进入了B实例的bar方法
当前线程名: 主线程 企图调用B实例的last方法
当前线程名: 副线程 企图调用A实例的last方法
可以看到程序既无法向下执行，也不会抛出任何异常，就一直僵持着。
程序中两个线程执行，副线程的线程执行体是DeadLock类的run方法，主线程的线程执行体是DeadLock的main()方法。其中run()方法中让B对象调用bar()方法，init()方法让A对象调用foo()方法。