多线程的学习笔记

多线程学习笔记

1.线程简介

1.多任务

在同一时刻运行多个程序的能力

2程序

程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。

3.线程(Thread)

线程是CPU调度和执行的单位。一个进程中可以包含多个线程，至少一个进程中有一个线程。

4.进程(Process)

进程是执行程序一次执行过程，它是一个动态的概念。是系统资源分配的单位。

5.多线程

真正的多线程是指多个CPU,即多核，如服务器。如果是模拟出来的多线程，即在一个CPU的情况下，在同一个时间点，CPU只能执行一个代码，因为切换的很快，所以就有同时执行的错觉。

6.多线程与多进程有哪些区别

本质区别在于每个进程拥有自己的一整套变量，而进程则是共享数据。

2.线程实现（重点）

新的执行线程java的API文档中给出了两种创建方式，分别是：

1.继承Thread类

1. 自定义一个线程类继承Thread类
2. 重写**run()**方法，编写线程执行体
3. 创建线程对象，调用**start()**方法

public class ThreadDemo1 extends Thread{
    
    
    @Override
    public void run() {
    
    
        for (int i=1;i<20;i++){
    
    
            System.out.print(i+"\t");
        }
    }
    public static void main(String[] args) {
    
    
        ThreadDemo1 threadDemo1 = new ThreadDemo1();
        threadDemo1.start();
    }
}

运行结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-708q9Kju-1602751656407)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20201007094912018.png)]

线程调度不一定执行，由Cpu调度执行

例：运用多线程从网络上下载图片。

1. 导入commons-io-2.8.0.jar
2. 构建下载器
3. 创建Thread对象的实例
4. 开启线程

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;

/*练习Thread实现 多线程同步下载图片*/
public  class TestThread2 extends Thread {
    
    
    private  String url;
    private  String name;


    /*构造器*/
    public TestThread2(String url,String name){
    
    
        this.url=url;
        this.name=name;
    }

    @Override
    public void run() {
    
    
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url,name);
        System.out.println("下载了文件名为"+name);
    }

    public static void main(String[] args) {
    
    
        TestThread2 t1 = new TestThread2("https://pics0.baidu.com/feed/f636afc379310a5537cdba89774726ae832610ef.png?token=a2399949c6ee9c74e25dd5af516fb557"
                ,"1.jpg");
        TestThread2 t2 = new TestThread2("https://pics2.baidu.com/feed/aa64034f78f0f736cf334eee0e17ef1ee9c413dc.jpeg?token=5bb47f749e0ef8c712219274d45cc829"
                ,"2.jpg");
        TestThread2 t3 = new TestThread2("https://pics7.baidu.com/feed/5fdf8db1cb134954d815e1de66e9f15fd0094aab.jpeg?token=6f7d330e69e35629a1b8bbcc78b06333"
                ,"3.jpg");
       t1.start();
       t2.start();
       t3.start();
    }
}
/*下载器*/
class  WebDownloader{
    
    

    /*下载方法*/
    public  void downloader(String url,String name){
    
    

        try {
    
    
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
    
    
            e.printStackTrace();
            System.out.println("io异常,downloader");
        }
    }
}

运行结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MRrwZvF5-1602751656409)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20201007103516458.png)]

由运行结果可以看出并不是按照顺序执行，同时执行。

2.实现Runnable接口

1. 自定义一个线程类实现Runnable接口
2. 重写run()方法
3. 创建Runnable对象的实例
4. 启动线程 new Thread(参数).start();

/*实现Runnable接口*/
public class TestThread3 implements Runnable {
    
    
    int x;
    public TestThread3(int x){
    
    
        this.x=x;
    }
    /*重写run方法*/
    @Override
    public void run() {
    
    
        for (int i=0;i<x;i++){
    
    
            System.out.println("run方法执行了"+i);
        }
    }

    public static void main(String[] args) {
    
    
        TestThread3 t1 = new TestThread3(20);
    /*启动线程*/
        new Thread(t1).start();
    }
}

例：通过实现Runnable接口实现网络图片的下载

import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;

public class TestThread4  implements Runnable{
    
    
    private  String url;
    private  String name;


    /*构造器*/
    public TestThread4(String url,String name){
    
    
        this.url=url;
        this.name=name;
    }

    @Override
    public void run() {
    
    
        WebDownloader1 webDownloader = new WebDownloader1();
        webDownloader.downloader(url,name);
        System.out.println("下载了文件名为"+name);
    }

    public static void main(String[] args) {
    
    
        TestThread4 t1 = new TestThread4("https://pics0.baidu.com/feed/f636afc379310a5537cdba89774726ae832610ef.png?token=a2399949c6ee9c74e25dd5af516fb557"
                ,"1.jpg");
        TestThread4 t2 = new TestThread4("https://pics2.baidu.com/feed/aa64034f78f0f736cf334eee0e17ef1ee9c413dc.jpeg?token=5bb47f749e0ef8c712219274d45cc829"
                ,"2.jpg");
        TestThread4 t3 = new TestThread4("https://pics7.baidu.com/feed/5fdf8db1cb134954d815e1de66e9f15fd0094aab.jpeg?token=6f7d330e69e35629a1b8bbcc78b06333"
                ,"3.jpg");
        new Thread(t1).start();
        new Thread(t2).start();
        new Thread(t3).start();
    }
}
/*下载器*/
class  WebDownloader1{
    
    

    /*下载方法*/
    public  void downloader(String url,String name){
    
    

        try {
    
    
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
    
    
            e.printStackTrace();
            System.out.println("io异常,downloader");
        }
    }
}

1.了解并发

并发：同一个对象被多个线程同时操作如：火车抢票系统。

/*初识并发*/
public class TestThread5 implements Runnable {
    
    

    private int ticketnums = 20;

    @Override
    public void run() {
    
    
        while (true) {
    
    
            if (ticketnums <= 0) {
    
    
               break;
            }
            //延迟买票不可能一直买
            try {
    
    
                Thread.sleep(200);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"拿到了第"+ ticketnums-- + "张票");
        }
    }

    public static void main(String[] args) {
    
    

        TestThread5 t = new TestThread5();
        new Thread(t, "小王").start();
        new Thread(t, "小张").start();
        new Thread(t, "黄牛党").start();

    }
}

运行结果：会出现两个人拿到同一张票，但是票只有一张，会出现明显的问题。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5IcsUMEy-1602751656411)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20201007113422706.png)]

案例：龟兔赛跑

public class Race implements Runnable{
    
    

    private String winner;
//    设置跑道
    @Override
    public void run() {
    
    
        for (int i = 0; i <= 100; i++) {
    
    
            //判断是否有胜利者
                Boolean flag=gameOver(i);
                if(flag){
    
    
                    break;
                }
//                使兔子休息
                if(Thread.currentThread().getName().equals("兔子")){
    
    
                    try {
    
    
                        Thread.sleep(20);
                    } catch (InterruptedException e) {
    
    
                        e.printStackTrace();
                    }
                }
            System.out.println(Thread.currentThread().getName()+"跑了"+i+"米");

        }
    }
//判断是否游戏结束
    public boolean gameOver(int steps){
    
    
        //判断是否有胜利者
        if(winner!=null){
    
    
            return true;
        }

        if(steps>=100){
    
    
            winner=Thread.currentThread().getName();
            System.out.println("winner is"+winner);
            return true;
        }
        return false;
    }
//
    public static void main(String[] args) {
    
    
        Race race = new Race();
        new Thread(race,"兔子").start();
        new Thread(race,"乌龟").start();
    }
}

3.实现Callable接口（了解即可）

1. 实现Callable接口，需要返回值类型
2. 重写call方法，需要抛出异常
3. 创建目标对象
4. 创建执行服务： ExecutorService ser= Executors.newFixedThreadPool(3);
5. 提交执行：Future rs1 = ser.submit(t1);
6. 获取结果：Boolean b1 = rs1.get();
7. 关闭服务：ser.shutdownNow();

案例：通过callable接口实现网络图片的下载。

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.*;

public class TestThread6  implements Callable<Boolean> {
    
    
    private String url;
    private String name;

    public TestThread6(String url ,String name){
    
    
        this.url=url;
        this.name=name;
    }


    @Override
    public Boolean call() {
    
    
        WebDownloader2 webDownloader2=new WebDownloader2();
        webDownloader2.downloader(url,name);
        System.out.println("下载了名为："+name);
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
    
    

        TestThread6 t1 = new TestThread6("https://pics0.baidu.com/feed/f636afc379310a5537cdba89774726ae832610ef.png?token=a2399949c6ee9c74e25dd5af516fb557"
                ,"1.jpg");
        TestThread6 t2 = new TestThread6("https://pics2.baidu.com/feed/aa64034f78f0f736cf334eee0e17ef1ee9c413dc.jpeg?token=5bb47f749e0ef8c712219274d45cc829"
                ,"2.jpg");
        TestThread6 t3 = new TestThread6("https://pics7.baidu.com/feed/5fdf8db1cb134954d815e1de66e9f15fd0094aab.jpeg?token=6f7d330e69e35629a1b8bbcc78b06333"
                ,"3.jpg");
        //创建执行服务
        ExecutorService ser= Executors.newFixedThreadPool(3);
        //提交执行
        Future<Boolean> rs1 = ser.submit(t1);
        Future<Boolean> rs2 = ser.submit(t2);
        Future<Boolean> rs3 = ser.submit(t3);
        //获取结果
        Boolean b1 = rs1.get();
        Boolean b2 = rs2.get();
        Boolean b3 = rs3.get();

        System.out.println(b1);
        System.out.println(b2);
        System.out.println(b3);
        //关闭服务
        ser.shutdownNow();

    }
}
class  WebDownloader2{
    
    

    /*下载方法*/
    public  void downloader(String url,String name){
    
    

        try {
    
    
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
    
    
            e.printStackTrace();
            System.out.println("io异常,downloader");
        }
    }
}

3.线程状态

1.新建状态

new thread(); 尚未启动的线程处于此状态

2.就绪状态

线程调用start()方法

3.运行状态

获得执行权 在java虚拟机中执行的线程处于此状态

4.阻塞状态

被阻塞等待监视器锁定的线程处于此状态

5.死亡状态

已退出的线程处于此状态

6.线程状态图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-okXDuchf-1602751656438)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20201008163958095.png)]

1.线程停止（stop）

• 不推荐使用JDK提供的stop（）、destroy（）【已废弃】
• 推荐线程自己停止下来
• 建议使用一个标志位来进行终止变量，当flag=false，则终止线程运行

1. 设置一个标志位
2. 不要使用stop（）方法或者destroy（）方法等过时的或者JDK不建议的使用的方法。

public class teststop  implements Runnable {
    
    
    //1.设置一个标志位
    private Boolean flag=true;

    @Override
    public void run() {
    
    
        int i=0;
        while (flag){
    
    
            System.out.println("线程运行了"+i++);
        }
    }
    //2.设置一个公开的方法停止线程，转换标志位
    public void stop(){
    
    

                this.flag=false;

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

        for (int i = 0; i < 1000; i++) {
    
    
            System.out.println("main"+i);
            if(i ==900){
    
    
                //3.调用stop方法切换标志位，让线程停止。
                teststop.stop();
                System.out.println("线程停止了");
            }
        }

    }
}

2.线程休眠（sleep）

• sleep（时间）指定当前线程阻塞的毫秒数（1000毫秒=1秒）
• sleep存在异常InterruptedException
• sleep时间达到后线程进入就绪状态
• sleep可以模拟网络延迟，倒计时等
• 每一个对象都有一个锁，sleep不会释放锁

1.模拟倒计时

//模拟倒计时
public class TestSleep2 {
    
    
    
    public  static void tenDown() throws InterruptedException {
    
    

        int num =10;
        while(true){
    
    
            Thread.sleep(1000);
            System.out.println(num--);
            if(num<=0){
    
    
                break;
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
    
    
        tenDown();

    }
}

2.模拟网络延时

//模拟网络延时：放大问题的发生性
public class TestSleep implements Runnable{
    private int ticketnums = 20;

    @Override
    public void run() {
        while (true) {
            if (ticketnums <= 0) {
                break;
            }
            //模拟延时
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"拿到了第"+ ticketnums-- + "张票");
        }
    }

    public static void main(String[] args) {

        TestSleep t = new TestSleep();
        new Thread(t, "小王").start();
        new Thread(t, "小张").start();
        new Thread(t, "黄牛党").start();

    }
}

3.线程礼让（yield）

• 线程礼让，让当前正在执行的线程暂停，但不阻塞
• 将线程从运行状态转为就绪状态
• 让cpu重新调度，礼让不一定成功!!!看CPU心情

//测试礼让，礼让不一定成功看cpu心情
public class TestYield {
    
    
    public static void main(String[] args) {
    
    
        MyYield myYield = new MyYield();
        new Thread(myYield,"a").start();
        new Thread(myYield,"b").start();
    }
}

class MyYield implements Runnable{
    
    
    @Override
    public void run() {
    
    
        System.out.println(Thread.currentThread().getName()+"线程开始执行");
        Thread.yield();//线程开始礼让
        System.out.println(Thread.currentThread().getName()+"线程停止执行");
    }
}

4.线程强制执行（join）

join方法非常霸道，自己先执行，其他的线程进入阻塞状态。（想象成插队）

public class TestJoin implements Runnable   {
    
    

    @Override
    public void run() {
    
    
        for (int i = 0; i < 1000; i++) {
    
    
            System.out.println("join" + i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
    
    
        //启动线程
        TestJoin testJoin=new TestJoin();
        Thread thread = new Thread(testJoin);
        thread.start();
        
        //主线程
        for (int i = 0; i < 200; i++) {
    
    
            if(i==100){
    
    
              thread.join();
            }
            System.out.println("main"+i);
        }
    }

}

5.线程优先级（priority）

public class TestPriority {
    
    
    public static void main(String[] args) {
    
    
        //主线程的默认优先级
        System.out.println(Thread.currentThread().getName()+"---->"+Thread.currentThread().getPriority());
        MyPriority myPriority=new MyPriority();

        Thread t1 = new Thread(myPriority);
        Thread t2 = new Thread(myPriority);
        Thread t3 = new Thread(myPriority);
        Thread t4 = new Thread(myPriority);
        Thread t5 = new Thread(myPriority);

        t1.start();
        //先设置优先级
        //之后再开启线程
        t2.setPriority(6);
        t2.start();

        t3.setPriority(Thread.MAX_PRIORITY);
        t3.start();

        t4.setPriority(Thread.MIN_PRIORITY);
        t4.start();

        t5.setPriority(3);
        t5.start();
    }
}
class MyPriority implements Runnable{
    
    
    @Override
    public void run() {
    
    
        //获得线程的名称和线程优先级
        System.out.println(Thread.currentThread().getName()+"---->"+Thread.currentThread().getPriority());
    }
}

运行结果一：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CPo4NAgX-1602751656441)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20201008160543464.png)]

运行结果二;

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XRB3lZm3-1602751656442)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20201008160641323.png)]

运行结果三：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8cmvfJIs-1602751656443)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20201008160709390.png)]

等等

注意点：

优先级低只是意味着获得调度的概率低，并不是优先级低就不会被调用。这都是看CPU的调度。

所以优先级高的并不一定比优先级低的先执行。

6.守护线程(daemon)

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

//守护线程的测试
//上帝守护着你
public class TestDaemon {
    
    

    public static void main(String[] args) {
    
    

        God god = new God();
        You you = new You();

        Thread thread = new Thread(god);
        //设置为守护线程，
        thread.setDaemon(true);
        thread.start();
        //创建新的线程
        Thread t1 = new Thread(you);
        t1.start();
    }
}

//上帝
class  God implements Runnable{
    
    
    @Override
    public void run() {
    
    
        while(true){
    
    
            System.out.println("上帝守护着你");
        }
    }
}

//自己

class You implements Runnable{
    
    
    @Override
    public void run() {
    
    
        for (int i = 0; i < 1000; i++) {
    
    
            System.out.println("你活了"+i+"天");
        }
        System.out.println("good bye world");
    }

}

注意：虚拟机不会等待守护线程的结束。

4.线程同步（重点）

• 现实生活中会遇到 ”同一个资源，多个人都想使用“的问题，如去食堂吃饭需要排队，火车的买票等等。

• 处理多线程的问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象。这时候我们就需要线程同步。

• 线程同步是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用。

• 由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加入了
  锁机制 synchronized当一个线程获得该对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可，存在一下的问题

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

1. 线程不安全案列：

1.买票的不安全

public class UnsafeBuyTicket {
    
    

    public static void main(String[] args) {
    
    
        BuyTicket01 b = new BuyTicket01();
        new Thread(b,"张三").start();
        new Thread(b,"李四").start();
        new Thread(b,"王五").start();
    }


}

class BuyTicket01 implements Runnable{
    
    
    //设置票数
    private int ticketnums  = 20;
    //设置一个标志位
    private  Boolean  flag  =true;

    @Override
    public void run() {
    
    
        //买票
        while (flag){
    
    
            buy();
        }

    }
    //买票的方法
    public void buy(){
    
    
        //设置标志位
        if(ticketnums<=0){
    
    
            flag =false;
            return;
        }
        //模拟延时
        try {
    
    
            Thread.sleep(2000);
        } catch (InterruptedException e) {
    
    
            e.printStackTrace();
        }
        //买票的具体方法
        System.out.println(Thread.currentThread().getName()+"获得了第" +ticketnums--+
                "张票");
    }
}

2.银行取钱的不安全

public class UnsafeBank {
    
    
    public static void main(String[] args) {
    
    
        Account account = new Account("家庭存款", 100);
        //你取钱
        Drawing you = new Drawing(account, 50, "you");
        you.start();
        //你妈妈去取钱
        Drawing youmom = new Drawing(account, 100, "youmom");
        youmom.start();
    }

}
//账户
class Account {
    
    
    //账户的名字
    private String name;
    //账户的钱数
    private int money;

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

    public String getName() {
    
    
        return name;
    }

    public void setName(String name) {
    
    
        this.name = name;
    }

    public int getMoney() {
    
    
        return money;
    }

    public void setMoney(int money) {
    
    
        this.money = money;
    }
}


//模拟银行取钱
class Drawing extends Thread{
    
    

    private Account  account;
    private int drawingMoney;
    private String name;


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

    @Override
    public void run() {
    
    
       if(account.getMoney()-drawingMoney<0){
    
    
           System.out.println(account.getName()+"卡里钱不够了，取不了了");

           return;
       }
       //模拟延时放大问题
        try {
    
    
            Thread.sleep(1000);
        } catch (InterruptedException e) {
    
    
            e.printStackTrace();
        }
        //卡内余额
        account.setMoney(account.getMoney()-drawingMoney);
        System.out.println(account.getName()+"余额为"+account.getMoney());

       //你手里的钱
        System.out.println(this.name+"手里的钱："+drawingMoney);

    }
}

3.线程的不安全

//线程不安全
//这个例子就是list集合长度达不到10000
//同一个瞬间把两个数组添加在同一个位置覆盖掉了
public class UnsafeList {
    
    
    public static void main(String[] args) {
    
    
        ArrayList<String> list = new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
    
    
            new Thread(()->{
    
    
                list.add(Thread.currentThread().getName());
            }).start();
        }
        try {
    
    
            Thread.sleep(1000);
        } catch (InterruptedException e) {
    
    
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

2. 线程同步方法

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

同步方法

  public  synchronized void method(int args){
    
    }

• synchronized方法控制对“对象”的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才会获得这个锁，继续执行

  ​ **缺陷:**若将一个大的方法申明为synchronized将会影响效率

• 方法中只有修改的内容才需要锁，锁的太多，浪费资源。

• 同步代码块：synchronized(Obj){}

• Obj称之为同步监视器

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

• 同步监视器的执行过程

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

3.死锁

• 多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形，某一个同时拥有“两个以上对象的锁”时，就可能会发生”死锁“的问题

例：化妆，只有一个口红，一个镜子，有两个女孩g1和g2，一个女孩个g1先拥有口红，一个女孩先g2拥有镜子，g1和g2都想拥有其他的东西，就会发生死锁现象。不会同时拥有的。

public class DeadLock {
    
    
    public static void main(String[] args) {
    
    
        MakeUp g1 = new MakeUp(0, "g1");
        MakeUp g2 =new MakeUp(1,"g2");
        g1.start();
        g2.start();
    }

}
//口红
class Lipstick{
    
    

}
//镜子
class  Mirror{
    
    

}


class MakeUp extends  Thread{
    
    
    //需要的资源只有一份，用static来保证只有一份
    static Lipstick lipstick=new Lipstick();
    static Mirror mirror=new Mirror();

    int  choice;
    String girlname;
    public MakeUp(int choice,String girlname){
    
    
        this.choice=choice;
        this.girlname=girlname;
    }

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

    public  void makeup() throws InterruptedException {
    
    

        if(choice==0){
    
    
            synchronized (lipstick){
    
    
                System.out.println(this.girlname+"获得口红的锁");
                try {
    
    
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
    
    
                    e.printStackTrace();
                }
                synchronized (mirror){
    
    
                    System.out.println(this.girlname+"获得镜子的锁");
                }
            }
        }
        else{
    
    
            synchronized (mirror){
    
    
                System.out.println(this.girlname+"获得镜子的锁");

                Thread.sleep(2000);
                synchronized (lipstick){
    
    
                    System.out.println(this.girlname+"获得口红的锁");=
                }
            }
        }
    }
}

运行结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2ZOlyTOF-1602751656444)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20201013094506586.png)]

1.产生死锁的四个必要条件

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

我们只需要想办法破上边的一条或者多条条件就可以避免死锁发生。

4.Lock（锁）

1. 从JDK5.0开始。Java提供了更强大的线程同步机制-----通过显示定义同步锁对象来实现同步。同步锁使用Lock对象充当。
2. Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
3. ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock,可以显示加锁、释放锁。

private final ReentrantLock  lock  = new  ReenTrantLock();  
	lock.lock();//开锁
try{
    
    
     //保证线程安全的代码
}
finally{
    
    
      lock.unlock();//解锁
    //如果同步代码有异常，要将unlock()写入finally 语句块
}

例：买票的问题

必须到定义锁并且加锁跟解锁

import java.util.concurrent.locks.ReentrantLock;

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

        new Thread(testLock01,"张三").start();
        new Thread(testLock01,"李四").start();
        new Thread(testLock01,"王五").start();
    }
}
class testLock01 implements Runnable{
    
    
    private int ticketnums=10;
    
    //定义一个lock锁
    private final ReentrantLock lock=new ReentrantLock();
    @Override
    public void run() {
    
    
        while (true){
    
    
            lock.lock();//开锁
            try {
    
    
                
                if (ticketnums>0){
    
    
                   /* try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }*/
                    System.out.println(Thread.currentThread().getName()+"买了第"+ticketnums--+"张票");
                }else {
    
    
                    break;
                }
            }finally {
    
    
                lock.unlock();//解锁
            }

        }
    }
}

5.synchronized 与 Lock 的对比

1. Lock是显示锁（手动开启和关闭锁，别忘记关闭锁）synchronized是隐式锁，出了作用域自动释放
2. Lock只有代码块锁。synchronized有代码块锁和方法锁
3. 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的拓展性（提供更多的子类）
4. 优先顺序
   • Lock>同步代码块（已经进入方法体，分配了相应资源）>同步方法（在方法体之外）

5.线程通信问题

1.线程协作（生产者消费者模式）

应用场景：

1. 假设仓库只能存放一个产品，生产者将生产出来的产品放入仓库，消费者将仓库中产品取走消费
2. 如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止
3. 如果仓库中放有产品，则消费者可以直接取走，否则停止消费等待，直到仓库中再次放入产品即可。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lytOJ0Gh-1602751656445)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20201013111853185.png)]

问题分析：

这是一个线程同步的问题，生产者跟消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件

• 对于生产者，没有生产之前，要通知消费者等待，而生产了产品之后，又需要马上通知消费者消费
• 对于消费者，在消费之后，要通知生产者已经结束消费，需要生产新的产品以供消费
• 在生产者有消费者问题上仅有synchronized是不够的
  • synchronized可阻止并发更新同一个共享资源，实现同步
  • synchronized不能用来实现不同线程之间的消息传递（通信）

java中提供了几个方法解决线程之间的通信问题**（Object类）**

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

1.解决方法一：管程法

• 生产者：负责生产数据的模块（可能是方法、对象、线程、进程）
• 消费者：负责处理数据的模块（可能是方法、对象、线程、进程）
• 缓冲区：消费者不能直接使用生产者的数据，他们之间有个“缓冲区”

生产者将生产好的产品放在了缓冲区，消费者从缓冲区拿出数据

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pN9zKFNp-1602751656446)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20201013111853185.png)]

代码演示：买鸡跟炸鸡的过程

//测试生产者消费者模型--->利用缓冲区解决：管程法
//生产者
//消费者
//产品
//缓冲区
public class TestPC {
    
    
    public static void main(String[] args) {
    
    
        Syncontainer container = new Syncontainer();

        new Producer(container).start();
        new Consumer(container).start();
    }
}
//生产者
class Producer extends Thread{
    
    
//需要一个容器
    Syncontainer container;
    public Producer(Syncontainer container){
    
    
        this.container=container;
    }
    @Override
    public void run() {
    
    
        for (int i = 1; i < 100; i++) {
    
    

            container.push(new Chicken(i));
            System.out.println("生产了第"+i+"只鸡");
        }

    }
}
//消费者
class Consumer extends Thread{
    
    
    //需要一个容器
    Syncontainer container;
    public Consumer(Syncontainer container){
    
    
        this.container=container;
    }

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

        }
    }
}
//产品
class Chicken{
    
    
    int id;
  public Chicken(int id){
    
    
      this.id=id;
  }

}
//缓冲区
class Syncontainer{
    
    
    //需要一个容器大小
    Chicken[] chickens=new Chicken[10];
    //设置一个计数
    int count =0;
    //生产者放入产品
    public  synchronized  void push(Chicken chicken){
    
    
        //如果容器满了。就需要等待消费者消费
        if(count == chickens.length){
    
    
            //通知消费者消费，生产等待
            try {
    
    
                this.wait();
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
        }
        //如果没有满，我们就需要丢入产品
        chickens[count]=chicken;
        count++;
        //通知消费者消费
        this.notifyAll();
    }
    //消费者消费产品
    //消费者消费产品
    public synchronized Chicken  pop(){
    
    
        //如果容器为0，就需要等待生产者生产
        if(count==0){
    
    
            //等待生产者生产，消费者等待
            try {
    
    
                this.wait();
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
        }
        //如果可以消费
        count--;
        Chicken chicken1 = chickens[count];
        //吃完了，通知生产者生产
        this.notifyAll();
        //返回吃的鸡
        return  chicken1;
    }
}

2.解决方法二：信号灯法

通过标记flag来确定

例子：电视节目中演员与观众

//测试生产者消费者问题2：信号灯法，标志位法
public class TestPC2 {
    
    
    public static void main(String[] args) {
    
    
        Program program = new Program();
        new Performer(program).start();
        new Audience(program).start();

    }
}

//生产者--->演员
class Performer extends Thread{
    
    

    Program program;
    public Performer(Program program){
    
    
        this.program=program;

    }

    @Override
    public void run() {
    
    
        for (int i = 1; i < 100; i++) {
    
    
            program.player("西游记"+ i);
        }

    }
}
//消费者--->观众
class Audience  extends Thread{
    
    
    Program program;
    public  Audience (Program program){
    
    
        this.program=program;
    }

    @Override
    public void run() {
    
    
        for (int i = 1; i < 100; i++) {
    
    
            program.watcher();
        }
    }
}
//产品--->节目
class Program{
    
    

    //演员表演，观众等待True
    //观众观看，演员等待False
    String  voice;
    boolean flag = true;
    //表演节目
    public  synchronized void player(String voice){
    
    

        if(!flag){
    
    
            try {
    
    
                this.wait();
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
        }
        System.out.println("演员表演了"+ voice);
        //通知观众观看
        this.notifyAll();
        //通知唤醒voice
        this.voice=voice;
        //该变标志位
        this.flag= !this.flag;

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

        //通知演员表演了
        this.notifyAll();
        this.flag=!this.flag;
    }
}

2.线程池

• 背景：经常创建和销毁，使用量特别大的资源，比如并发情况下的线程，对性能影响很大
• 思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中，可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具
• 好处
  • 提高响应速度（减少创建新线程的时间）
  • 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
  • 便于线程管理（…）
    • corePoolSize：核心池的大小
    • maximumPoolSize:最大线程数
    • keepAliveTime:线程没有任务时最多保持多长时间后会终止
• JDK 5.0起提供了线程池相关的API：ExecutorService和Executors
• ExecutorService:真正的线程池接口。常见的子类ThreadPoolExecutor
  • void execute(Runnable command):执行任务/命令，没有返回值，一般执行Runnable
  • Futuresubmit (Callabletask):执行任务，有返回值，一般又来执行Callable
  • void shutdown():关闭连接池
• Executors:工具类、线程池的工厂类，用于创建并返回不同类型的线程池

代码演示：

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

public class TestPool {
    
    
    public static void main(String[] args) {
    
    

        //1.创建线程池，创建线程池
        //newFixedThreadPool参数为：线程池的个数
        ExecutorService service= Executors.newFixedThreadPool(10);
        //2.将线程放入池子中执行runnable接口的实现类
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        //3.关闭连接
        service.shutdown();
    }
}
class MyThread  implements Runnable{
    
    
    @Override
    public void run() {
    
    
        for (int i = 0; i < 100; i++) {
    
    
            System.out.println(Thread.currentThread().getName()+i);
        }
    }
}