11_多线程

前言

本次内容全部来自

• 哔哩哔哩遇见狂神说：https://space.bilibili.com/95256449/channel/index

线程简介

Java.Thread

什么是多任务

多任务看起来是多个任务都在做，但是其实同一个时间都在做一件事情，只不过切换的非常快

普通方法和多线程

程序，进程，线程

操作系统中运行的程序都是进程

一个进程中存在多个线程

Process与Thread

• 程序是指令和程序的有序集合，其本身没有任何运行的含义，是一个静态的概念
• 进程则是执行程序的一次执行过程，他是一个动态的概念。
• 进程是系统资源分配的单位
• 一个进程中存在多个线程，至少有一个线程。
• 线程是CPU调度和执行的单位

很多多线程是模拟出来的，真正的多线程是指有多个cpu，如服务器。

如果是模拟出来的多线程，在同一个cpu下面，在同一个时间点，cpu只可以执行一个代码，因为切换的很快，所以就有同时执行的错觉

• 线程就是独立的执行路径
• 在程序运行时，即使没有自己创建线程，后台也会有多个线程,如主线程, gc线程
• main()称之为主线程,为系统的入口，用于执行整个程序
• 在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度,调度器是与操作系统紧密相关的，先后顺序是不能人为的干预的

多线程带来的问题

• 对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制
• 线程会带来额外的开销，如cpu调度时间，并发控制开销
• 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致

多线程带来的好处

1、充分利用CPU资源，长时间占用CPU资源的线程可以适当地将时间分给其他的线程，不至于一直占用

2、在一个线程工作的同时可以让其他工作一直处于活动状态

3、可以分别设置优先级别来优化性能

以下任务最适合使用多线程

1、耗时长的，阻碍其他事务操作的任务

2、必须要等待外部资源的任务，比如IO

线程实现

三种方法

三种：Thread，Runnable，Callable

1. 继承Thread类，重写run方法并开启它
2. 实现Runnable接口
3. 实现Callable接口（重要）

start和run的区别

• run()：它只是类中的一个普通方法，调用run方法之后，程序中并不会多出一个线程，还是按照main线程的
• start()：使用start方法可以开辟出一个新的线程，和main线程同步执行

调用start之后，线程就会进入到就绪状态，一旦被CPU分配了时间片，就会自动调用run方法来执行程序

这里的run方法称为线程体，它包含了这个线程要执行的内容，run方法结束之后，线程停止

Thread

/*
* 1. 继承Thread
* 2. 重写Run
* 3. 调用start
* */
public class ThreadDemo1 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 200; i++) {
            System.out.println("thread的run方法执行了...");
        }
    }


    //主线程执行
    public static void main(String[] args) {

        ThreadDemo1 thread = new ThreadDemo1();
        
        thread.start();
        
        for (int i = 0; i < 1000; i++) {
            System.out.println("主线程执行");
        }
        
    }
}

线程开启之后不一定立刻执行，由CPU调度

实现Runnable

/*
* 1. 实现Runnable
* 2. 重写run方法
* 3. 通过Thread来调用。执行线程需要丢入runnable接口的实现类
* 4. 调用start
* */
public class RunnableDemo1 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 200; i++) {
            System.out.println("thread的run方法执行了...");
        }
    }


    //主线程执行
    public static void main(String[] args) {

        RunnableDemo1 runnable = new RunnableDemo1();

        Thread thread = new Thread(runnable);

        thread.start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("main方法执行...");
        }

    }
}

对比实现Runnable和继承Thread，推荐实现Runnable，因为java是单继承

实现Callable

/*
* 1. 实现Callable接口，需要返回值类型
* 2. 重写call方法，需要抛出异常
* 3. 创建目标对象
* 4. 创建执行任务
* 5. 提交执行
* 6. 获取结果
* 7. 关闭服务
* */
public class CallableDemo1 implements Callable<Boolean> {//这里的泛型是Boolean

    private String name;

    public CallableDemo1(String name) {
        this.name = name;
    }

    @Override
    public Boolean call() throws Exception {
        System.out.println("call方法执行："+name);
        return true;//永远返回true
    }




    public static void main(String[] args) {

        //新建了三个callable
        CallableDemo1 callable1 = new CallableDemo1("callable1");
        CallableDemo1 callable2 = new CallableDemo1("callable2");
        CallableDemo1 callable3 = new CallableDemo1("callable3");

        // 创建执行服务，创建了一个线程池，里面有3个线程
        ExecutorService service = Executors.newFixedThreadPool(3);

        //把三个callable提交执行
        Future<Boolean> submit1 = service.submit(callable1);
        Future<Boolean> submit2 = service.submit(callable2);
        Future<Boolean> submit3 = service.submit(callable3);

        //获得结果
        try {
            Boolean result1 = submit1.get();
            Boolean result2 = submit2.get();
            Boolean result3 = submit3.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        //关闭服务
        service.shutdown();
    }

}

静态代理

我们以结婚为例子，作为静态代理的例子

package com.bean.proxy;

//代理对象和真实对象都要实现一个接口
interface Marry{
    void HappyMarry();
}

//真实对象
class Man implements Marry{

    @Override
    public void HappyMarry() {
        System.out.println("男方结婚");
    }
}

//代理对象，婚庆公司
class WeddingCompany implements Marry{

    //代理的目标，真实对象
    private Marry target;

    public WeddingCompany(Marry target) {
        this.target = target;
    }

    @Override
    public void HappyMarry() {
        before();
        //实现真实对象的代理
        target.HappyMarry();
        after();
    }

    private void before(){
        System.out.println("结婚之前布置现场");
    }

    private void after(){
        System.out.println("结婚之后收钱");
    }
}

public class StaticProxy {
    public static void main(String[] args) {
        Man man = new Man();
        WeddingCompany weddingCompany = new WeddingCompany(man);
        weddingCompany.HappyMarry();
    }

}

1. 真实对象和代理对象都要实现同一个接口
2. 代理对象要代理真实角色

好处：

1. 代理对象可以做真实对象做不了的
2. 真实对象专注于自己的事情

Lambda

为什么要使用lambda

• 避免匿名内部类定义过多
• 可以让代码觉得简洁
• 去掉了没有意义的代码

函数式接口

假如一个接口只包含一个抽象方法，那么就叫做函数式接口

函数式接口可以实现Lambda

---

public class LambdaDemo1{

    public static void main(String[] args) {
        ILike like = ()->System.out.println("输出");
    }
}

interface ILike{
    void show();
}

package com.bean.lambda;

public class LambdaDemo1{

    public static void main(String[] args) {
        ILike like = ()->{
            System.out.println("输出");
            System.out.println("另一句输出");
        };
    }
}

interface ILike{
    void show();
}	

public class LambdaDemo1{

    public static void main(String[] args) {
        ILike like = i->System.out.println("输出"+i);
    }
}

interface ILike{
    void show(int i);
}

public class LambdaDemo1{

    public static void main(String[] args) {
        ILike like = (i,s)->System.out.println("输出"+i+s);
    }
}

interface ILike{
    void show(int i,String s);
}

线程状态

线程的五大状态

线程方法

方法	说明
setPriority(int newPriority)	更改线程的优先级
static void sleep(long millis)	在指定的毫秒数内让当前正在执行的线程休眠
void join()	强制插队，其他线程要等待该线程终止
static void yield()	中断线程（线程礼让），不推荐使用 推荐使用一个boolean flag，让线程自己停下
boolean isAlive()	测试线程是否存活

注意：

1、高优先级的线程不一定首先执行，一切要看CPU的调度。但是高优先级的线程会有更多的机会先执行。

2、高优先级的线程礼让也不一定会让低优先级的线程先执行，还是先看CPU的调度

3、join可以做到强制插队的效果，可以保证这个插队的线程先走完

线程停止

public class StopDemo implements Runnable {

    //设置一个标志位
    boolean flag = true;

    @Override
    public void run() {
        int i = 0;
        while (flag){
            System.out.println(i+ "");
            i++;
        }
    }

    public void stop(){
        flag = false;
    }

    public static void main(String[] args) {
        StopDemo stop = new StopDemo();

        new Thread(stop).start();

        for (int i = 0; i < 1000000; i++) {
            if (i==900000){
                stop.stop();
            }
        }

    }
}

线程休眠

public class SleepDemo implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(i+"");
            if (i== 5){
                try {
                    Thread.sleep(3000);//线程休眠
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
        SleepDemo sleep = new SleepDemo();
        new Thread(sleep).start();
    }
}

线程休眠可以模拟网络延时，放大问题

每一个对象都有一个锁，但是sleep不会释放锁

线程礼让

让当前执行的线程停止，但是不阻塞

礼让不一定成功，看cpu

public class YiledDemo {
    public static void main(String[] args) {
        MyYield yield = new MyYield();
        //第二个参数：给线程起名字
        new Thread(yield,"A").start();
        new Thread(yield,"B").start();
    }
}

class MyYield implements Runnable{

    @Override
    public void run() {
    	//Thread.currentThread().getName()：获取线程名字
        System.out.println(Thread.currentThread().getName()+"线程开始执行");
        Thread.yield();//礼让
        System.out.println(Thread.currentThread().getName()+"线程停止执行");
    }
}

线程强制执行

通俗讲就是插队

public class JoinDemo implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("线程vip插队");
        }
    }

    public static void main(String[] args) {
        JoinDemo join = new JoinDemo();
        Thread thread = new Thread(join);
        thread.start();

        for (int i = 0; i < 50; i++) {
            if (i==20){
                try {
                    thread.join();//等待thread插队
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("main"+i);
        }
    }
}

注意，Join可以保证vip这个线程先走完

线程状态观测

Thread.State

• Thread.State.New：新生：尚未启动
• Thread.State.Runnable：运行：在JVM中执行
• Thread.State.Block：阻塞
• Thread.State.Waiting：一直等待：等待另一个线程执行动作
• Thread.State.Timed_Waiting：过时不候：等待另一个线程指定动作达到指定的事件
• Thread.State.Terminated：结束：退出的线程

死亡的线程不能再启动了，所以线程只能启动一次

Thread.State state = thread.getState();

线程的优先级

JAVA提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调用哪个线程来执行

线程的优先级用数字来显示，范围从1~10

• Thread.MIN_PRIORITY=1
• Thread.MAX_PRIORITY=10
• Thread.NORM_PRIORITY=5

以下方式改变线程或者获取线程的优先级

• getPriority()
• setPriority(int xxx)

主线程是默认优先级

//测试线程优先级
public class PriorityDemo1 extends Thread{

    public static void main(String[] args) {
        //主线程是默认优先级
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());    //main-->5

        MyPriority priority = new MyPriority();

        Thread thread1 = new Thread(priority);
        Thread thread2 = new Thread(priority);
        Thread thread3 = new Thread(priority);
        Thread thread4 = new Thread(priority);
        Thread thread5 = new Thread(priority);
        Thread thread6 = new Thread(priority);
        Thread thread7 = new Thread(priority);


        thread1.start();        //Thread-0-->5

        thread2.setPriority(1);     //Thread-1-->1
        thread2.start();

        thread3.setPriority(4);     //Thread-2-->4
        thread3.start();

        thread4.setPriority(Thread.MAX_PRIORITY);   //Thread-3-->10
        thread4.start();

    /*
        main-->5
        Thread-3-->10
        Thread-0-->5
        Thread-2-->4
        Thread-1-->1
     */

    }

}

class MyPriority implements Runnable {

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
    }
}

注意了，其实并不是优先级高的时候就一定先跑，只不过是提高了先跑的概率

cpu也有可能先调用优先级低的，这种情况叫做性能倒置，不过一般不会出现

而且要注意，要先设置优先级，然后在启动

守护线程

线程分为用户线程和守护线程

• 虚拟机必须保证用户线程执行完毕
• 虚拟机不用等待守护线程执行完毕
• 守护线程如：后台记录操作日志，监控内存，垃圾回收等等

public class GuardDemo {
    public static void main(String[] args) {
        Guard guard = new Guard();

        User user = new User();

        Thread userThread = new Thread(user);  //默认都是用户线程

        Thread guardThread = new Thread(guard); //默认都是用户线程
        guardThread.setDaemon(true);    //设置为守护线程，默认都是用户线程

        guardThread.start();
        userThread.start();
    }
}

class Guard implements Runnable{

    @Override
    public void run() {
        while (true){
            System.out.println("守护线程");
        }
    }
}


class User implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("用户线程");
        }
    }
}

线程同步

• 并发：多个线程操作同一个资源

  比如10000去抢一张票，两个银行同时去取钱

  对于并发问题，我们需要用到对象的等待池去排队

• 队列和锁

  形成队列之后，我们也要保证同一个资源在同一时间只有一个线程可以访问，这个时候我们就需要用到锁，来保证资源的访问

  我们在之前在讲解sleep说过，每个对象都拥有一把锁，而sleep不会释放锁

也就是说，解决并发问题安全性需要两步：

1. 多个线程形成队列
2. 资源上锁

---

在访问的时候假如锁机制：synchronized，当一个线程获得对象的排它锁，独占资源，其余线程必须等待，使用之后释放锁即可

存在以下问题：

• 一个线程持有锁会导致其他所有需要此锁的线程挂起，效率变低了
• 多线程竞争下，加锁和释放锁会导致比较多的上下文切换和调度延时，引起性能问题
• 如果一个优先级高的线程等待一个线程优先级低的线程释放锁，那么会导致优先级倒置，引起性能问题

不安全例子

• 买票

//线程不安全
public class UnSafeDemo {

    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();

        new Thread(buyTicket,"A").start();
        new Thread(buyTicket,"B").start();
        new Thread(buyTicket,"C").start();
    }
}

class BuyTicket implements Runnable{

    private int ticket = 10;//10张票
    private boolean flag = true;
    @Override
    public void run() {
        //买票
        while (flag){
            buy();
        }
    }

    private void buy(){
        if (ticket<=0){
            flag =false;
            return;
        }

        try {
            Thread.sleep(100);//模拟延时，增大问题发生率
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //买票
        System.out.println(Thread.currentThread().getName()+"-->"+ticket--);
    }
}

每个线程都有自己的工作内存开销，内存控制不当会导致数据不一致

在这个例子里，有可能会导致抢到了同一张票的情况，甚至可能会有抢到了负数的情况

• 银行取钱

//两个人去银行取钱
public class UnSafeDemo2 {
    public static void main(String[] args) {
        Account account = new Account(100,"基金");

        Drawing man = new Drawing(account,50,"男方");
        Drawing women = new Drawing(account,100,"女方");

        man.start();
        women.start();
        /*
        基金余额为：0
        基金余额为：-50
        女方手里的钱：100
        男方手里的钱：50
         */
    }
}

//账户
class Account{
    int money;  //余额
    String name;//卡号

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}

//银行，模拟取款
class Drawing extends Thread{
    Account account;//账户
    int drawingMoney;//取了多少钱
    int nowMoney;   //现在手里有多少钱

    public Drawing(Account account,int drawingMoney,String name){
        super(name);//给Thread起名字
        this.account = account;
        this.drawingMoney = drawingMoney;
    }

    @Override
    public void run() {
        //判断有钱么
        if (account.money-drawingMoney<0){
            System.out.println(Thread.currentThread().getName()+"：钱不够");
            return;
        }

        //模拟延时
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //卡内余额
        account.money = account.money-drawingMoney;
        //手中的钱
        nowMoney = nowMoney+drawingMoney;

        System.out.println(account.name+"余额为："+account.money);
        System.out.println(this.getName()+"手里的钱："+nowMoney);
    }
}

• 集合

//线程不安全的集合
public class UnSafeList {
    public static void main(String[] args) {
        List<String> lists = new ArrayList<>();

        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
               lists.add(Thread.currentThread().getName());
            }).start();
        }
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(lists.size());   //9997
    }
}

集合是不安全的

集合不安全的原因在于：线程的内存都是各自的，我们会发现每一个线程都有自己的内存，但是线程操作的都是一个资源

对于每一个线程来说，所看到的资源是全部的，但是程序不知道还会有其他线程来操作资源

所以就会出现这种问题

归根结底的问题就是：线程在自己的工作内存进行交互

同步方法和同步代码块

由于我们可以通过private关键字来保证数据对象只能被方法访问，所以我们只需要对方法提出一套机制，这套机制就是synchronized关键字，它包括两种用法：

同步方法

类似：public synchronized void method(int args){}，只需要在方法上加上synchronized即可

synchronized方法访问控制对对象的访问
每一个对象对应一把锁

每一个synchronized方法都必须获得该方法的对象的锁才可以执行，否则线程就会被阻塞

方法一但执行，就独占该锁，直到方法返回才释放锁，后面被阻塞的线程才可以获得这个锁，继续执行

缺陷：若将一个大的方法声明为synchronized，将会影响效率

缺陷：

我们知道，只读代码其实并不需要加锁，但是修改代码需要加锁

如果我们使用同步方法，那么只读代码也会被加上锁，影响效率

我们对上面不安全的例子进行修改，比如修改买票的例子：

public class UnSafeDemo {

    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();

        new Thread(buyTicket,"A").start();
        new Thread(buyTicket,"B").start();
        new Thread(buyTicket,"C").start();
    }
}

class BuyTicket implements Runnable{

    private int ticket = 10;
    private boolean flag = true;
    @Override
    public void run() {
        while (flag){
            buy();
        }
    }

    private synchronized void buy(){    //我们只需要在修改的方法上加上同步标签，将这个方法改为同步方法
        if (ticket<=0){
            flag =false;
            return;
        }

        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(Thread.currentThread().getName()+"-->"+ticket--);
    }
}

加上了同步代码块之后，实现了

1. 排队
2. 锁

这样实现了同步代码块的锁定

但是我们注意，这个锁的意思是锁定了一个对象，因为每一个对象都有一把锁

我们加上了同步标签锁定的是这一个对象，但是假如拥有了多个对象，这个同步方法就没用了

看下面的例子：

public class UnSafeDemo2 {
    public static void main(String[] args) {
        Account account = new Account(100,"基金");

        Drawing man = new Drawing(account,50,"男方");
        Drawing women = new Drawing(account,100,"女方");

        man.start();
        women.start();
    }
}


class Account{
    int money;  
    String name;

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}


class Drawing extends Thread{
    Account account;
    int drawingMoney;
    int nowMoney;   

    public Drawing(Account account,int drawingMoney,String name){
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;
    }

    @Override
    public synchronized void run() {

        if (account.money-drawingMoney<0){
            System.out.println(Thread.currentThread().getName()+"：钱不够");
            return;
        }


        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


        account.money = account.money-drawingMoney;

        nowMoney = nowMoney+drawingMoney;

        System.out.println(account.name+"余额为："+account.money);
        System.out.println(this.getName()+"手里的钱："+nowMoney);
    }
}

如果你去运行这个代码，你会发现：

这个同步方法好像没有用

分析：

我们锁定的是Run方法，而run方法对应的对象是Drawing对象，所以我们操作的锁其实是Drawing的锁

但是我们增删改的对象并不是Drawing对象，而是Account对象

所以同步方法没用了

同步代码块

对于上面的问题，我们可以使用同步代码块来进行实现同步

同步代码块：synchronized(obj){}

其中obj称为同步监视器

• obj可以为任何对象，但是推荐使用共享资源作为同步监视器
• 同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this这个对象本身，或者是class

• 同步监视器的执行过程
  1. 第一个线程访问，锁定同步监视器，执行其中代码
  2. 第二个线程访问，发现同步监视器被锁定，无法访问
  3. 第一个线程访问完毕，解锁同步监视器
  4. 第二个线程访问，锁定同步监视器，执行其中代码

例子，还是上面那个银行取钱的案例

public class UnSafeDemo2 {
    public static void main(String[] args) {
        Account account = new Account(100,"基金");

        Drawing man = new Drawing(account,50,"男方");
        Drawing women = new Drawing(account,100,"女方");

        man.start();
        women.start();
    }
}


class Account{
    int money;
    String name;

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}


class Drawing extends Thread{
    Account account;
    int drawingMoney;
    int nowMoney;

    public Drawing(Account account,int drawingMoney,String name){
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;
    }

    @Override
    public void run() {

       synchronized (account){
           if (account.money-drawingMoney<0){
               System.out.println(Thread.currentThread().getName()+"：钱不够");
               return;
           }


           try {
               Thread.sleep(1000);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }


           account.money = account.money-drawingMoney;

           nowMoney = nowMoney+drawingMoney;

           System.out.println(account.name+"余额为："+account.money);
           System.out.println(this.getName()+"手里的钱："+nowMoney);
       }
    }
}

成功了

我们锁定的是公共资源，这里的公共资源其实就是account

或者可以这样认为：我们进行增删改的对象是account，但是我们执行的方法是run，run对应的对象不是增删改所对应的对象，所以使用同步代码块，锁住公共资源

---

CopyOnWriteArrayList

首先看下面一段代码：

import java.util.concurrent.CopyOnWriteArrayList;

public class TestJUC {

    public static void main(String[] args) {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();

        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
               list.add(Thread.currentThread().getName());
            }).start();
        }
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

运行完成之后发现：这个是线程安全的

点进源码看一下：

---

死锁

线程只有获取完整的资源才可以运行，但是现在多个线程平分了这些共享资源

线程占有着自己的资源，并且都等待着其他的线程释放另外的资源，因为资源不完全，这些线程全部都不能执行

这种情况叫做死锁

多个线程互相抱着对方需要的资源，然后形成僵持

某一个同步块同时拥有两个以上对象的锁时，就可能发生死锁现象

public class DeadLock {
    public static void main(String[] args) {
        Makeup girl1 = new Makeup(0,"grilA");
        Makeup girl2 = new Makeup(1,"girlB");

        girl1.start();
        girl2.start();
    }
}

//口红
class Lipstick{

}

//镜子
class Mirror{

}

class Makeup extends Thread{

    //使用static来保证只有一份
    static Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();

    int choice;//选择
    String girlName;

    Makeup(int choice,String girlName){
        this.choice = choice;
        this.girlName =girlName;
    }


    @Override
    public void run() {
        //化妆
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    //化妆需要互相持有对方的锁，就是需要拿到对方的资源
    private void makeup() throws InterruptedException {
        if (choice==0){
            synchronized (lipstick){//获得口红的锁
                System.out.println(girlName+"获得口红的锁");
                Thread.sleep(1000);
                synchronized (mirror){//1秒钟之后想要获得镜子的锁
                    System.out.println(girlName+"获得镜子的锁");
                }
            }
        }else {
            synchronized (mirror){//获得镜子的锁
                System.out.println(girlName+"获得镜子的锁");
                Thread.sleep(2000);
                synchronized (lipstick){//2秒钟之后想要获得口红的锁
                    System.out.println(girlName+"获得口红的锁");
                }
            }
        }
    }
}

这样的话，程序卡住了，因为这样会导致死锁

这是因为：

• A和B都想要对方的锁
• A和B都没有释放锁的途径

所以会产生死锁

我们知道，A和B想要对方的锁没有关系，但是一定要让A和B有释放锁的途径，否则只是期待资源而不释放资源，早晚会产生死锁的现象

我们这么改：

public class DeadLock {
    public static void main(String[] args) {
        Makeup girl1 = new Makeup(0,"grilA");
        Makeup girl2 = new Makeup(1,"girlB");


        girl1.start();
        girl2.start();
    }

}



//口红
class Lipstick{

}

//镜子
class Mirror{

}

class Makeup extends Thread{

    //使用static来保证只有一份
    static Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();

    int choice;//选择
    String girlName;

    Makeup(int choice,String girlName){
        this.choice = choice;
        this.girlName =girlName;
    }


    @Override
    public void run() {
        //化妆
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    //化妆需要互相持有对方的锁，就是需要拿到对方的资源
    private void makeup() throws InterruptedException {
        if (choice==0){
            synchronized (lipstick){//获得口红的锁
                System.out.println(girlName+"获得口红的锁");
                Thread.sleep(1000);
            }
            synchronized (mirror){//1秒钟之后想要获得镜子的锁
                System.out.println(girlName+"获得镜子的锁");
            }
        }else {
            synchronized (mirror){//获得镜子的锁
                System.out.println(girlName+"获得镜子的锁");
                Thread.sleep(2000);
            }
            synchronized (lipstick){//2秒钟之后想要获得口红的锁
                System.out.println(girlName+"获得口红的锁");
            }
        }
    }
}

这个办法就是把里面的同步代码块放到了外面，这样虽然A和B还是期望对方的锁，但是A和B都有释放锁的途径

得不到锁，在代码执行完之后还是会释放锁

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

• 互斥条件：一个资源每次只能被一个进程使用
• 请求与保持：一个进程因为请求资源而被阻塞时，对已经获得的资源保持不放
• 不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺
• 循环等待条件：若干进程形成一种头尾相接的循环等待资源关系

这四个条件只要剥夺一条，就会破开死锁的局面

而往往比较容易破开的条件就是请求与保持条件

Lock

从JDK5.0开始，JAVA提供了一个更加强大的线程同步机制：通过显式定义同步锁对象来实现同步。Lock对象充当同步锁

java.util.concurrent.locks.Lock接口是控制多个线程对共享资源访问的工具

锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应该先获得Lock对象

ReentrantLock类实现了Lock（可重用锁），它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显示加锁，释放锁

public class LockDemo {
    public static void main(String[] args) {
        TestLock testLock = new TestLock();

        new Thread(testLock).start();
        new Thread(testLock).start();
        new Thread(testLock).start();
    }
}


class TestLock implements Runnable{

    //定义Lock锁
    private final ReentrantLock lock = new ReentrantLock();

    int ticket = 10;

    @Override
    public void run() {
        while (true){
            lock.lock();//加锁

            try {
                if (ticket>0){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(ticket--);
                }else {
                    break;
                }
            } finally {
                lock.unlock();
            }
        }
    }
}

Synchronized与Lock对比

Lock

1. 是显示锁（手动开启和关闭锁，不要忘记关闭）

2. 只有代码块锁

3. JVM将花费较少的时间来调度线程，性能更好，并且有更好的扩展性（子类更多）

Synchronized

1. 是隐式锁，出了作用域自动释放

2. 有代码块锁和方法锁

优先级：Lock>同步代码块>同步方法块

---

线程通信

生产者和消费者模式

生产者和消费者并不是一个模式，而是一个问题，不是23中设计模式之一

生产者是一个线程

消费者是一个线程

生产者生产产品放到仓库，消费者从仓库中取走消费

仓库中只可以存放一个产品

如果仓库中没有产品，则生产者将产品放入仓库，直到仓库中的产品被消费者取走为止才可以继续生产

如果仓库中存在产品，消费者可以从仓库取走产品，如果仓库中没有产品则一直等待

这是一个线程同步问题

生产者和消费者共享同一个资源，消费者和生产者共享同一个资源，而且这两者之间相互依赖，互为条件

在生产者和消费者问题中，仅有synchronized是不够的

• synchronized可以阻止并发更新同一个资源，实现同步
• 但是不可以用来实现不同线程之间的通信

JAVA提供了几个方法来解决线程中的通信问题

方法名	作用
wait()	表示线程会一直等待，直到其他线程通知，sleep不会释放锁，但是wait()会释放锁
wait(long timeout)	指定等待的毫秒数
notify()	唤醒一个处于等待状态的线程
notifyAll()	唤醒同一个对象上所有调用wait()方法的线程，优先级高的线程优先调度

注意：都是使用Object类的方法，都只能在同步方法或者同步代码块中使用

否则会抛出异常IlllegalMonitorStateException

解决方式

1. 做一个缓冲区，生产者将生产好的数据放入缓冲区，消费者从缓冲区拿取数据（管程法）
2. 做一个标志flag（信号灯法）

---

管程法

//生产者，消费者，产品，缓冲区，
public class Tube {
    public static void main(String[] args) {

        Synchro synchro = new Synchro();

        new Productor(synchro).start();
        new Consumer(synchro).start();
    }
}

//产品
class Chiken{
    int id;//产品编号

    public Chiken(int id) {
        this.id = id;
    }
}

//缓冲区
class Synchro{
    //容器大小
    Chiken[] chikens = new Chiken[10];

    int count = 0;//容器计数器

    //生产者放入产品
    public synchronized void push(Chiken chiken){
        //假如容器满了，那么等待消费者消费
        if (count==chikens.length){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //假如容器没有满，那么就需要丢入产品
        chikens[count] = chiken;
        count++;
        //通知消费者消费
        this.notifyAll();
    }


    //消费者消费产品
    public synchronized Chiken pop(){

        //假如没有鸡，等待生产者生产
        if (count==0){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        //假如可以消费
        count--;
        Chiken chiken = chikens[count];

        //通知生产者生产
        this.notifyAll();
        
        return chiken;
    }
}

//生产者
class Productor extends Thread{

    Synchro container = new Synchro();

    Productor(Synchro container){
        this.container = container;
    }

    @Override
    public void run() {
        //生产
        for (int i = 0; i < 20; i++) {
            container.push(new Chiken(i));
            System.out.println("生产了第"+i+"只鸡");
        }
    }
}

//消费者
class Consumer extends Thread{

    Synchro container = new Synchro();

    Consumer(Synchro container){
        this.container = container;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            container.pop();
            System.out.println("消费了第"+i+"只鸡");
        }
    }
}

生产者只管生产

消费者只管消费

而缓冲区协调生产和消费

信号灯法

//信号灯法一般使用标志位
public class Flag {
    public static void main(String[] args) {
        TV tv = new TV();
        new Player(tv).start();
        new Watcher(tv).start();
    }
}

//产品
class TV{
    //演员表演，观众等待
    //观众观看，演员等待

    //表演的节目
    String voice;

    //标志位
    boolean flag = true;

    //表演
    public synchronized  void play(String voice){
        if (!flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("演员表演了..."+voice);
        //通知观众观看
        this.notifyAll();//通知唤醒
        this.voice = voice;
        this.flag = !this.flag;
    }

    //观看
    public synchronized void watch(){
        if (flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("观看了："+voice);

        this.notifyAll();//唤醒演员
        this.flag = !this.flag;
    }
}

//生产者
class Player extends Thread{
    TV tv;

    public Player(TV tv){
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if (i%2==0){
                this.tv.play("节目");
            }else {
                this.tv.play("广告");
            }
        }
    }
}

//消费者
class Watcher extends Thread{
    TV tv;

    public Watcher(TV tv){
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            tv.watch();//观看
        }
    }
}

演员只管表演

观众只管看

TV作为标志位来协调

---

线程池

我们之前经常创建和销毁线程，对性能影响很大

假如我们提前创建好多个线程，放入线程池中，用的时候直接用，用完之后放回线程池

好处：

• 减少了创建新线程的事件，提高响应速度
• 重复利用线程池中的线程，降低资源消耗
• 便于线程管理

JDK5提供了真正关于线程池相关的API：ExecutorService，Executors

ExecutorService：真正的线程池接口，常见子类ThreadPoolExecutor

• void execute(Runnable command)：执行任务/命令，没有返回值，一般用来执行Runnable
• <T>Future<T> submit(Callable<T> task)：执行任务，有返回值，一般用来执行Callable
• void shutdown()：关闭线程池

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {}

ThreadPoolExecutor的构造方法

1、corePoolSize：线程数据量，核心线程多少

2、maximumPoolSize：线程池中最大容量

3、keepAliveTime：当线程池线程数量大于corePoolSize时候，多出来的空闲线程，多长时间会被销毁。

4、unit 时间单位。TimeUnit

5、workQueue 任务队列，用于存放提交但是尚未被执行的任务。我们可以选择如下几种：

• ArrayBlockingQueue：基于数组结构的有界阻塞队列，FIFO（先进先出）
• LinkedBlockingQueue：基于链表结构的有界阻塞队列，FIFO
• SynchronousQueue：不存储元素的阻塞队列，每个插入操作都必须等待一个移出操作，反之亦然
• PriorityBlockingQueue：具有优先级别的阻塞队列

6、threadFactory 线程工厂，用于创建线程，一般可以用默认的

7、handler 拒绝策略，所谓拒绝策略，是指将任务添加到线程池中时，线程池拒绝该任务所采取的相应策略。

什么时候拒绝？

当向线程池中提交任务时，如果此时线程池中的线程已经饱和了，而且阻塞队列也已经满了，则线程池会选择一种拒绝策略来处理该任务，该任务会交给RejectedExecutionHandler处理

线程池提供了四种拒绝策略：

1、AbortPolicy：直接抛出异常，默认策略

2、CallerRunsPolicy：用调用者所在的线程来执行任务

3、DiscardOldestPolicy：丢弃阻塞队列中靠最前的任务，并执行当前任务

4、DiscardPolicy：直接丢弃任务

Executors：工具类，线程池的工厂类，用于创建并返回不同类型的线程池

---

//测试线程池
public class Pool {
    public static void main(String[] args) {
        //创建服务，创建线程池，10个线程
        ExecutorService service = Executors.newFixedThreadPool(10);

        //放入Runnable里面的实现类
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());

        //关闭链接
        service.shutdown();
    }

}

class MyThread implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

请注意，在阿里的Java开发手册规约上，强制不可以使用Executors创建线程池：

线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险

Executors各个方法的弊端：
1、newFixedThreadPool 和 newSingleThreadExecutor：主要问题是堆积的请求处理队列可能会耗费非常大的内存，甚至OOM。
2、newCachedThreadPool 和 newScheduledThreadPool：主要问题是线程数最大数是Integer.MAX_VALUE，可能会创建数量非常多的线程，甚至OOM。