Java多线程-笔记

1、目录（要学习的知识）

2、多线程简介

2.1、 多任务

好比一个人边吃饭边玩手机，看起来是吃饭和玩手机是一起做的，但并不是这样其实本质上来讲是一会吃饭一会看手机，同一时间做一个任务

2.2、多线程

一个线程只能给一个程序使用，如果需要第二个程序则需要创建第二个线程给程序2提供线入。

（就好比一条小道上一次只能通过一辆车，车多了就会发送拥堵效率低为了提高效率，扩建道路将道路分成一条条小道，一次性可以通过多辆车大大提高了效率）

不使用和使用多线程的过程图：

2.3、进程

1）、一个进程有多个线程，如看视频可以听到使用、发弹幕、播放视频等；

2）、进程Process与线程Thread

程序执行为---进程里面有---多个线程

• 说起进程，就不得不说下程序。程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。
• 而进程则是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位
• 通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程， 不然没有存在的意义。线程是CPU调度和执行的的单位。

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

3、线程创建

3.1、创建线程有三中方式：

1）、Thread类：

使用该类创建线程，需要让自定义的类继承该类，并重写该类的run()方法来编写线程执行体，在创建该线程对象调用start()方法启动线程 线程不一定执行，CPU调度安排

//创建线程方式一:继承Thread类，重写run()方法 ，调用start开启线程
//总结:注意, 线程开后不一定立即执行，由CPU调度执行
public class TestThread1 extends Thread {
    @Override
    public void run() {
        for(int i=0;i<200;i++) {
            System.out.println("我在看代码=="+i);
        }
    }
    
    public static void main(String[] args) {
        //main线程：主线程
        //创建一个线程对象
        TestThread1 test=new TestThread1();
        test.start();
        
        for(int i=0;i<1000;i++) {
            System.out.println("我在学习多线程=="+i);
        }
    }
}

 

2）、Runnable接口：

使用该接口创建线程，需要让自定义的类实现该接口，并重写run()抽象方法编写线程执行体，然后创建该实现类的对象将该实现类对象传给Thread对象调用start()方法启动线程

/*创建线程方式二:实现Runnable接口，重写run()方法 ，
执行线程需要丢入runnable接口实现类，调用start开启线程*/
public class TestThread2 implements Runnable {
    @Override
    public void run() {
        for(int i=0;i<200;i++) {
            System.out.println("我在看代码=="+i);
        }
    }
    
    public static void main(String[] args) {
        //创建runndable接口的实体类对象
        TestThread2 test2=new TestThread2();
        //创建一个线程对象,通过线程对象来开启我们的线程（代理）
        Thread thread=new Thread(test2);
        thread.start();
        
        for(int i=0;i<1000;i++) {
            System.out.println("我在学习多线程=="+i);
        }
    }
}

3）、Callable接口：

实现该接口需要返回值（泛型），并重写call方法需要抛出异常，创建该实现类的对象（目标对象）

1、创建执行服务: ExecutorService ser =Executors.newFixedThreadPool(1);

2、提交执行: Future<Boolean> result1 = ser.submit(t1);

3、获取结果: boolean r1 = result1 .get()

4、关闭服务: ser.shutdownNow();

public class CallableTest implements Callable<Boolean> {
    private String url;//网络图片路径
    private String name;//保存文件的名称
    
    public CallableTest() {}
    public CallableTest(String url,String name) {
        this.url=url;
        this.name=name;
    }
    
    //下载图片的线程执行体
    public Boolean call() {
        Xz1 xz=new Xz1();
        xz.xaizai(url, name);
        System.out.println("下载完成"+name);
        return true;
    }
    
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        CallableTest t1=new CallableTest("https://i0.hdslb.com/bfs/sycp/creative_img/202002/fcf948f538729637988488be9505f0ec.jpg@1100w_484h_1c_100q.jpg","1.jpg");
        CallableTest t2=new CallableTest("https://i0.hdslb.com/bfs/archive/058056424b94c3ff8c1facc940f48ce3bfe423a5.jpg@1100w_484h_1c_100q.jpg","2.jpg");
        CallableTest t3=new CallableTest("https://i0.hdslb.com/bfs/archive/c5b8e10627f5f880f5a644cfd36260e3662a638c.jpg@1375w_605h_1c_100q.webp","3.jpg");
        
        //3个线程谁先下完 谁先结束线程
        ExecutorService ser=Executors.newFixedThreadPool(3);//创建执行服务器，指定有几个服务
        Future<Boolean> r1=ser.submit(t1);//提交执行
        Future<Boolean> r2=ser.submit(t2);
        Future<Boolean> r3=ser.submit(t3);
        System.out.println("返回结果"+r1.get());//获取返回结果
        System.out.println("返回结果"+r2.get());
        System.out.println("返回结果"+r3.get());
        ser.shutdownNow();//关闭服务
    }
}
​
//下载器
class Xz1{
    //下载方法
    public void xaizai(String url,String name) {
        try {
            //用FileUtil类中的
            FileUtils.copyURLToFile(new URL(url), new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("下载方法报出异常");
        }
    }
}

也可以用FutureTask<T>类来执行callable接口，因为该类实现了Runnable接口所以可以直接new一个Thread将该callable实现类放进去在.start()启动线程，用该类的get方法就可以获取到call方法的返回值

public static void main(String[] args) {
    FutureTask<Integer> futureTask=new FutureTask<>(new MyDome());
    new Thread(futureTask).start();
    try {
        Integer i=futureTask.get();
        System.out.println(i);
    }catch(Exception e1) {
        e1.printStackTrace();
    }
}
​
class MyDome implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        System.out.println("通过FutureTask执行Callable接口");
        return 100;
    }
}

 

3.2、小结：

在使用多线程操作同一个资源时，线程不安全，数据紊乱

4、静态代理

代理对象与真实对象都实现同一个接口，代理对象要代理真实角色

好处：代理对象可以做到真实对象做不了的事情，真实对象专注做自己的事情

（好比结婚，你是真实角色，婚庆公司代理你帮你处理结婚的事，线程对象Thread代理了Runnble接口）

5、线程状态

5.1、线程方法

5.2、停止线程

不推荐使用线程中的方法来停止线程，stop()、destroy()这些方法都已经过时了@Deprecated。

推荐线程自己停止，利用次数,不建议死循环。

使用一个标志位终止变量flag=false，则线程终止。

//测试(stop)
//1.建议线程正常停止--->利用次数,不建议死循环。
//2.建议使用标志位--->设置一个标志位
//3.不要使用stop或者destroy等过时或者JDK不建议使用的方法
public class TestStop implements Runnable {
    //1.设置一个标识位
    private boolean flag=true;
​
    @Override
    public void run() {
        int i=0;
        //2.线程体使用该标识
        while(flag) {
            System.out.println("run...Thread"+i++);
        }
    }
    
    //3.对外提供丰富改变标识
    public void stop() {
        this.flag=false;
    }
    
    public static void main(String[] args) {
        TestStop stop=new TestStop();
        
        new Thread(stop).start();
        
        for(int i=0;i<1000;i++) {
            System.out.println("main主线程"+i);
            if(i==500) {
                stop.stop();//调用方法改变标识
                System.out.println("线程该结束了");
            }
        }
    }
}

5.3、线程休眠sleep

1、sleep (时间)指定当前线程阻塞的毫秒数;

2、sleep存在异常InterruptedException;

3、sleep时间达到后线程进入就绪状态;

4、sleep可以模拟网络延时，倒计时等。

模拟网络延时：放大问题的发生性

5、每一个对象都有一个锁，sleep不会释放锁;

Thread t=new Thread(new Runnable() {            
    @Override
    public void run() {
        try {
            Thread.sleep(3000);//sleep()设置该线程休眠多少毫秒
            System.out.println("过去了三秒");
        }catch(Exception e) {
            System.out.println("线程中断");
        }
    }
});
t.start();
//用线程对象调用该方法，可以让线程捕捉到InteruptedExcepiton异常间接中断线程
t.interrupt();

5.4、线程礼让：Thread.yield()

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

（a线程在执行，a礼让回到就绪状态，这是b线程或其他线程有可能会运行，但有可能还是a线程执行）

//测试礼让线程
//礼让不一定成功，看cpu心情
public class TestYield {
    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() {
        System.out.println(Thread.currentThread().getName()+"线程开始执行");
        /* 礼让   
         * 礼让成功:a开始后面就是b开始
         * 礼让失败:a开始还是a结束
         */
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+"线程结束");
    }
}

5.5、线程join：线程对象.join()

Join合并线程，待此线程执行完成后，再执行其他线程，使用join的线程没有执行完时，其他线程阻塞（可以想象为插队）

public class JoinTest {
    public static void main(String[] args) {
        Thread t2=new Thread(new Runnable() {
            public void run() {
                System.out.println("我是线程B");
            }
        });
        Thread t1=new Thread(new Runnable() {
            public void run() {
                try {
                    System.out.println("我是线程A");
                    /*
                     * 当某个线程中其他线程对象调用了join()方法时,
                     * 所处线程会等待调用方法的线程执行完，在继续执行原线程
                     */
                    t2.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("我hai是线程A");
            }
        });
        t1.start();
        t2.start();
    }
}

public class JoinTest {
    public static void main(String[] args) {
        Thread t2=new Thread(new Runnable() {
            public void run() {
                System.out.println("我是线程B");
            }
        });
        Thread t1=new Thread(new Runnable() {
            public void run() {
                try {
                    System.out.println("我是线程A");
                    /*
                     * 当某个线程中其他线程对象调用了join()方法时,
                     * 所处线程会等待调用方法的线程执行完，在继续执行原线程
                     */
                    t2.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("我hai是线程A");
            }
        });
        t1.start();
        t2.start();
    }
}

public class JoinTest implements Runnable {
    public void run() {
        for(int i=0;i<500;i++) {
            System.out.println("vip"+i);
        }
    }
    public static void main(String[] args) {
        //启动线程
        JoinTest join=new JoinTest();
        Thread t=new Thread(join);
        t.start();
        //主线程
        for(int i=0;i<500;i++) {
            if(i==200) {
                try {
                    //很霸道的方法,主线程执行到200后,调用jion方法的线程就开始执行,直到该线程结束，主线程才继续执行
                    t.join();//插队
                }catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("main"+i);
        }
    }
}
​

5.5、线程状态观测

线程对象.getStart():获取线程现在的状态。

import java.lang.Thread.State;
​
public class TestStart {
    public static void main(String[] args) throws InterruptedException {
        Thread t=new Thread(()->{
            for(int i=0;i<4;i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("4秒后");
        });  
        
        State state=t.getState();//线程当前的状态 NEW
        System.out.println(state);
        
        t.start();
        state=t.getState();//Run
        System.out.println(state);
        
        while(state!=Thread.State.TERMINATED) {//只要线程不终止,就一直输出阻塞状态
            Thread.sleep(100);
            state=t.getState();
            System.out.println(state);
        }
    }
}

6、线程的优先级

线程调度器按照优先级决定一个调用哪个线程来执行，线程优先级用数字表示（1~10 默认优先级为5），使用getPriority()和setPriority(int i)来获取线程的优先级和设置优先级（设置优先级要在start()方法前调用）

优先级低只是意味着获得调度的概率低，并不是优先级低的就不会被调用（性能倒置），这都是看CPU调度

Thread t1 = new Thread(new Runnable() {
    public void run() {
        for (int i = 0; i < 50; i++) {
            System.out.println("t1" + " " + i);
        }
    }
});
Thread t2 = new Thread(new Runnable() {
    public void run() {
        for (int i = 0; i < 50; i++) {
            System.out.println("t2" + " " + i);
        }
    }
});
Thread t3 = new Thread(new Runnable() {
    public void run() {
        for (int i = 0; i < 50; i++) {
            System.out.println("t3" + " " + i);
        }
    }
});
​
t3.setPriority(1); //设置线程优先级
t2.setPriority(2);
t1.setPriority(3);
​
t1.start();
t2.start();
t3.start();

7、守护线程

线程分为用户线程和守护线程（线程对象.setDaemon(true);)

虚拟机必须保证用户线程（main）执行完毕

虚拟机不用等待守护线程（如gc()）执行完毕。(用户线程执行完毕，守护线程会自动关闭)

//测试守护线程 上帝守护你
public class TestDaemon {
    public static void main(String[] args) {
        God g=new God();
        You y=new You();
        
        Thread t=new Thread(g);
        t.setDaemon(true);//将上帝的线程设置守护线程
        t.start();//开启守护线程
        
        new Thread(y).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<36500;i++) {
            if(i==36499) {
                System.out.println("======古德拜======");
                break;
            }
            System.out.println("开心的活着");
        }
    }
    
}

8、线程同步(并发问题：多个线程使用同一资源 )

三大不安全线程案例

• 抢票

//不安全的抢票 不安全的线程
public class rob_fare implements Runnable {
    private int piao=10;//票数
    private boolean flag=true;//标识
    public static void main(String[] args) {
        rob_fare r=new rob_fare();
        
        /**
         * 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致
         * 下面的3个线程买票，都看到了还有最后一张是，将票拿到直接的工作内存中，买票
         * 在线程看来不会出问题，但程序中的数据就会出问题
         */
        new Thread(r,"1").start();
        new Thread(r,"2").start();
        new Thread(r,"3").start();
    }
​
    @Override
    public void run() {
        while(flag) {
            try {
                buy();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
    
    //synchronized方法 同步方法 锁的是this 加上synchronized就安全了
    public void buy() throws InterruptedException {
        if(piao<=0) {
            flag=false;
            return;
        }
        //模拟延时：放大问题的发生性
        Thread.sleep(100);
        System.out.println(Thread.currentThread().getName()+"抢到第"+piao--+"票");
    }
}

• 取钱

//不安全的线程
public class draw_money {
    public static void main(String[] args) {
        Account a=new Account(100, "过日子");
        
        new Drawing(a,50,"你").start();//你取了50万，还剩50
        new Drawing(a,100,"你老婆").start();//因为同时取钱所以,你老婆看到的还是100万,取了100万还剩-50
    }
}
class Account{
     int money;
     String name;
    public Account(int money, String name) {
        super();
        this.money = money;
        this.name = name;
    }
}
class Drawing extends Thread{
    private Account account;
    private int qu_money;
    private int m=0;
    
    public Drawing(Account account, int qu_money,String name) {
        super(name);
        this.account = account;
        this.qu_money = qu_money;
    }
    
    @Override
    public void run() {
        //synchronized (account) {//锁的是银行卡，因为银行卡上的钱需要改变
            //取钱操作
            if((account.money-qu_money)<0) {
                System.out.println("余额不足");
                return;
            }
            //放大问题的发生性
            try {
                this.sleep(2000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            //卡里剩余的钱
            account.money=account.money-qu_money;
            //取钱的人剩余的钱
            System.out.println(this.getName()+"现在有"+(m+qu_money));
            System.out.println("卡里剩余"+account.money);
        //}
    }
}

• 集合用线程存数据

public class shibai_List {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
​
        for (int i = 0; i < 10000; i++) {
            new Thread(() -> {
//              synchronized (list) {//同步块 锁的是list对象
                    list.add(Thread.currentThread().getName());
//              }
            }).start();
        }
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        // 因为多个线程为list添加数据，导致有事多个线程添加数据到同一个位置,所以数据数量有误
        System.out.println(list.size());
        
//      CopyOnWriteArrayList:JUC安全类型的集合
//      CopyOnWriteArrayList<String> list=new CopyOnWriteArrayList<>();
//      for (int i = 0; i < 10000; i++) {
//          new Thread(() -> {
//                  list.add("gjjgjh");
//          }).start();
//      }
//      try {
//          Thread.sleep(2000);
//      } catch (InterruptedException e) {
//          // TODO Auto-generated catch block
//          e.printStackTrace();
//      }
//      System.out.println(list.size());
    }
}

8.1、同步的概述

1）、解决并发问题，需要用线程同步。线程同步其实就是一种等待机制，多个线程同时访问一个对象时，访问的线程进入线程等待池中形成队列（排队），等待前面的线程结束，下一个线程才使用

2）、锁机制synchronized（同步的关键字）:在线程中每个对象都有一把锁，当一个线程获得对象的排它锁,独占资源,其他线程必须等待，使用完后释放锁。

队列 + 锁 = 线程同步的安全;

但存在以下的问题：

1、一个线程持有锁会导致其他所有需要此锁的线程挂起;

2、在多线程竞争下,加锁,释放锁会导致比较多的上下文切换和调度延时，引起性能问题;（要安全就要牺牲性能，相反也一样）

3、如果一个优先级高的线程等待一个优先级低的线程释放锁 会导致优先级倒置,引起性能问题.

每个线程在自己的工作内存交互，内存控制不当会造成数据不一致

（好比买票，取钱。多个线程同时买票，因为都看到最后还剩一张票(将这一张票copy到自己的工作内存空间来)，直接买，导致数据为负数。取钱差不多。

集合对象用线程添加数据，有会出现多个对象添加数据到同一位置。可以用同步，也可以用JUC里面的安全类型的集合CopyOnWriteArrayList解决并发问题）

8.2、同步方法

synchronized关键字：有两种用法synchronized方法 和synchronized块

1）、同步方法的synchronized 默认锁也是this（调用同步方法的类）

同步方法：public synchronized void method(int args){}

synchronized方法控制对“对象”的访问，每个对象对应一把锁每个synchronized方法都必须获取该方法的对象的锁才能执行，不然线程会阻塞。

执行过程：一但该方法执行，就独占该对象的锁，直到方法返回才释放锁，后面被阻塞的线程才能获得该锁继续执行

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

2）、同步块：

• 同步块 :synchronized (Obj ){ }

锁的是指定需要增删改的对象，代码块中是增删改的操作

synchronized（变化的对象）{
    变化对象的代码
}

• Obj 称之 同步监视器

  • Obj 可以是任何对象，但是推荐使用共享资源作为同步监视器

  • 同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，,就是这个对象本身,或者是class （用class对象调用）

• 同步监视器的执行过程

  1. 第一个线程访问，锁定同步监视器,执行其中代码.

  2. 第二个线程访问，发现同步监视器被锁定,无法访问.

  3. 第一个线程访问完毕，解锁同步监视器.

  4. 第二个线程访问，发现同步监视器没有锁,然后锁定并访问

同步块执行的执行的过程与同步方法一样

线程休眠不要放在线程同步中，因为休眠不会释放锁，休眠完毕程序会马上再次进入同步方法，在次锁住，所以其他线程拿不到锁

8.3、死锁

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

死锁案例：

public class si_suo {
    public static void main(String[] args) {
        new Thread(new Makeup(0,"灰姑娘")).start();
        new Thread(new Makeup(1,"白雪公主")).start();
    }
}
​
//口红
class Lipstick{}
//镜子
class Mirror{}
//女人
class Makeup implements Runnable{
    //需要资源只有一份，用static保证只有一份
    static Lipstick l=new Lipstick();
    static Mirror m=new Mirror();
    
    int choice;
    String name;
    public Makeup(int choice, String name) {
        this.choice = choice;
        this.name = name;
    }
    @Override
    public void run() {
        try {
            add();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    /**
     * 因为一个线程拿到了口红，另一个线程拿到了镜子，双方都需要对方的东西，
     * 又因为双方无法释放锁住的对象，所以两线程僵住程序卡死
     * 
     * 解决该问题，可以将里面同步块拿出来，这样就可以拿到对方的东西了，
     * 因为第一个线程拿到了口红使用完后释放该锁,第二个线程刚好也释放了一个对方所需要的锁,
     * 去拿第一个线程刚释放的锁，第一个线程去拿第二个线程刚释放的锁这样就可以解决死锁
     */
    public void add() throws InterruptedException {
        if(choice==0) {
            synchronized (l) {//拿到口红，释放对应的锁
                System.out.println(this.name+"拿到口红");
                Thread.sleep(1000);
//              synchronized (m) {//一秒后在拿到镜子
//                  System.out.println(this.name+"在拿到镜子");
//              }
            }
            synchronized (m) {//一秒后在拿镜子，因为选择镜子的人用完镜子了释放了锁，这时就可以拿到镜子了
                System.out.println(this.name+"在拿到镜子");
            }
        }else {
            synchronized (m) {//拿到镜子，释放对应的锁
                System.out.println(this.name+"拿到镜子");
                Thread.sleep(1000);
//              synchronized (l) {//一秒后在拿到口红
//                  System.out.println(this.name+"在拿到口红");
//              }
            }
            synchronized (l) {//一秒后在拿口红，因为选择镜子的人用完镜子了释放了锁，这时就可以拿到镜子了
                System.out.println(this.name+"在拿到口红");
            }
        }
    }
}

8.4、Lock锁

1、从jdk5开始，java提供更强大的线程同步机制，通过显示的同步锁对象来实现同步（Lock）

2、java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得lock对象(与synchronized相同)

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

使用lock锁的案例：

//不安全的抢票 不安全的线程
public class Lock_suo implements Runnable {
    private int piao=10;//票数
    private boolean flag=true;//标识
    
    private final ReentrantLock lock=new ReentrantLock();//定义lock锁对象
    
    public static void main(String[] args) {
        Lock_suo r=new Lock_suo();
        
        new Thread(r,"1").start();
        new Thread(r,"2").start();
        new Thread(r,"3").start();
    }
    @Override
    public void run() {
        while(flag) {
            try {
                lock.lock();//加锁
                buy();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }finally {
                lock.unlock();//解锁
            }
        }
    }
    
    //synchronized方法 同步方法 锁的是this 
    public void buy() throws InterruptedException {
        if(piao<=0) {
            flag=false;
            return;
        }
        //模拟延时：放大问题的发生性
        Thread.sleep(100);
        System.out.println(Thread.currentThread().getName()+"抢到第"+piao--+"票");
    }
}

 

9、线程协作

9.1、生产者消费者模式（问题）

解决该问题可以用管程法和信号灯法。

管程法：生产者生产的数据放入缓冲区，消费者从缓冲区拿数据，案例如下：

public class TestPC {
    public static void main(String[] args) {
        Warehouse w=new Warehouse();
        
        
        Productor p=new Productor(w);
        Consumer c=new Consumer(w);
        p.start();
        c.start();
    }
}
​
//生产者
class Productor extends Thread{
    Warehouse w;
    public Productor(Warehouse w) {
        this.w=w;
    }
    @Override
    public void run() {
        for(int i=1;i<=100;i++) {
            System.out.println("生产了"+i+"只鸡");
            w.push(new Chicken(i));
        }
    }
}
//消费者
class Consumer extends Thread{
    Warehouse w;
    public Consumer(Warehouse w) {
        this.w=w;
    }
    public void run() {
        for(int i=1;i<=100;i++) {
            System.out.println("消费了"+w.pop().id+"只鸡");
        }
    }
    
}
//产品
class Chicken{
    int id;
    public Chicken(int id) {
        this.id=id;
    }
}
//缓存区
class Warehouse {
    Chicken[] ch=new Chicken[10];//缓冲区大小
    int i=0;
    //生产者放入产品
    public synchronized void push(Chicken c) {
        if(ch.length==i) {
            //通知消费者来消费，生产者等待
            try {
                this.wait();//因为生产者调用了该方法，所以生产者等待
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        //如果产品没有放满，则继续放入
        ch[i]=c;
        i++;
        //通知消费者消费
        this.notifyAll();//唤醒生产者因为生产者在等待
    }
    //消费者消费产品
    public synchronized Chicken pop() {
        if(i==0) {
            //通知生产者来生产，消费者等待
            try {
                this.wait();//消费者调用该方法，所以消费者等待
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        //如果有产品则将产品拿出来
        i--;
        Chicken c=ch[i];
        
        //通知生产者生产
        this.notifyAll();//唤醒生产者，因为生产者等待了
        return c;
    }
}

 

信号灯法：给个标识符，为true等待，为false唤醒

可以用一下方法来完成线程通信，案例如下：

public class TestPC2 {
    public static void main(String[] args) {
        TV tv = new TV();
​
        new Player(tv).start();
        new Watcher(tv).start();
    }
}
​
//生产者 演员
class Player extends Thread {
    TV tv;
    public Player(TV tv) {
        this.tv = tv;
    }
​
    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            tv.play("西游记" + i);
        }
    }
}
​
//消费者 观众
class Watcher extends Thread {
    TV tv;
    public Watcher(TV tv) {
        this.tv = tv;
    }
​
    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            tv.watch();
        }
    }
}
​
//产品 节目
class TV {
    // 演员表演 观众等待 T
    // 观众观看 演员等待 F
    String voice;// 表演的节目
    boolean flag = true;//标识
​
    public synchronized void play(String voice) {
        if (!flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        System.out.println("演员表演了" + voice);
        this.voice = voice;
        this.flag = false;//将标识该变，是观众不会在进入方法再次等待，而演员等待
        this.notifyAll();//唤醒等待的观众
    }
​
    public synchronized void watch() {
        if (flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        System.out.println("观众观看的" + voice);
        this.flag = true;//将标识改变，使演员不会在进入方法再次等待，而观众等待
        this.notifyAll();//唤醒等待的演员
    }
}

等待唤醒方法：

10、线程池

为什么要使用线程池：因为经常创建和销毁，使用了特别大的资源。如并发的情况下，就很影响性能。

10.1、使用线程池

可以用ExecutorService接口和Executors工具类来使用线程池

1）、ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor。该接口有以下方法：

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

Executors . newFixedThreadPool(大小) ;：该方法是用来创建线程池并指定大小，是Executors类中创建线程池的方法

案例：

public class xianchengchi {
    public static void main(String[] args) {
        //创建服务，创建线程池
        ExecutorService e=Executors.newFixedThreadPool(3);
        //执行
        e.execute(new Add());
        e.execute(new Add());
        e.execute(new Add());
//      e.execute(new Add());线程超出线程池大小将会输出第一个线程
        //关闭服务
        e.shutdown();
    }
}
​
class Add implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

C:\Users\Admin\AppData\Local\YNote\data\qq9E4A200A5CE5CE782D90480A88BC8063\7e4d3461b01e4f6ebe76423eadb9e06f\clipboard.png