精华内容
下载资源
问答
  • 狂神说多线程笔记

    千次阅读 多人点赞 2020-09-26 10:33:09
    狂神说多线程笔记 bilibli视频地址:https://www.bilibili.com/video/BV1V4411p7EF/ 1.基本概念 Process和Thread 程序:指令和数据的有序集合,其本身没有任何运行的含义,是一个静态的概念。 进程:是执行程序的一...

    狂神说多线程笔记

    bilibli视频地址:https://www.bilibili.com/video/BV1V4411p7EF/

    1.基本概念

    Process和Thread

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

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

    ​ 一个进程可以包含有多个线程(如视频中同时听到声音、看到图像,还可以看弹幕)

    ​ 一个进程至少有一个线程,否则无存在的意义。

    线程:CPU调度和执行的单位。

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

    2.核心概念

    • 线程就是独立的执行路径;
    • 在程序运行时,即使没有自己创建线程,后台也会有多个线程,如主线程,gc线程;
    • main()称为主线程,为系统的入口,用于执行整个程序;
    • 在一个进程中,如果开辟了多个线程,线程的运行由调度器安排调度,调度器是与操作系统紧密相关的,先后顺序是不能认为干预的;
    • 对同一份资源操作时,会存在资源抢夺问题,需要加入并发控制;
    • 线程会带来额外的开销,如CPU调度时间,并发控制开销;
    • 每个线程在自己的工作内存交互,内存控制不当会造成数据不一致

    3.线程创建

    1.继承Thread类,重写run方法**

    a.创建Thread类

    b.重写run()方法

    c.调用start()开启线程

    //创建线程方式一:继承Thread类,重写run()方法,调用start()开启线程
    public class Test01 extends Thread{
    
    	@Override
    	public void run() {
    		//run方法线程体
    		for (int i = 0; i <20; i++) {
    			System.out.println("我在看代码");
    		}
    		
    	}
    	public static void main(String[] args) {
    		//main线程,主线程
    		
    		//创建一个线程对象
    		Test01 t= new Test01();
    //		t.run();     调用run()方法,执行完run方法体再执行main方法体
    		//调用start()方法开启线程     同时执行
    		t.start();
    		
    		for (int i = 0; i < 2000; i++) {
    			System.out.println(“我在学多线程"+i);
    		}
    	}
    }
    
    

    练习:网图下载

    总结:线程开启不一定立即执行,由CPU调度执行

    2.实现Runnable接口**

    a.实现Runnable接口

    b.重写run()方法

    c.执行线程需要创建runnable接口实现类,调用start()方法

    public static void main(String[] args) {
    		//创建一个线程对象
    		Test01 t= new Test01();
    		new Thread(t).start();
    		
    		for (int i = 0; i < 2000; i++) {
    			System.out.println(“我在学多线程"+i);
    		}
    	}
    

    练习:买火车票

    public class TestTread implements Runnable {
    	//票数
    	private int ticketNums = 10;
    
    	@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) {
    		TestTread ticket = new TestTread();
    		
    		new Thread(ticket,"小明").start();
    		new Thread(ticket,"老师").start();
    		new Thread(ticket,"黄牛").start();
    	}
    
    }
    
    

    案例:龟兔赛跑(待补)

    小结:以上两者区别

    • 继承Thread类:

      • 子类继承Thread类具备多线程能力
      • 启动线程:子类对象.start()
      • 不建议使用:避免OOP单继承局限性
    • 实现Runnable接口

      • 实现Runnable接口具备多线程能力
      • 启动线程:new Thread(子类对象).start()
      • 推荐使用:避免单继承局限性,方便同一个对象被多个线程使
    3.实现Callable接口
    • 实现Calleble接口

    • 重写call()方法

    • 创建执行服务

      ExecutorService ser = Executors.newFixedThreadPool(线程数);

    • 提交执行

      Future<返回值类型> r = ser.submit(线程名);

    • 获取结果

      类型 res=r.get();

    • 关闭服务

      ser.shutdownNow();

    总结:优点:1.可以定义返回值;2.能抛出异常

    ​ 缺点:相比而言较为麻烦

    4.静态代理

    ——多线程底层实现原理

    例子: 真实角色:你; 代理角色:婚庆公司; 结婚:实现结婚接口

    public class StaticProxy {
    	public static void main(String[] args) {
    		WeddingCompany company = new WeddingCompany(new You());
    		company.happyMarry();
    	}
    
    }
    
    interface Marry{
    	void happyMarry();
    }
    
    //真实角色
    class You 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();
    		this.target.happyMarry();
    		after();
    		
    	}
    
    	private void after() {
    		System.out.println("结婚之后,收尾款");
    		
    	}
    
    	private void before() {
    		System.out.println("结婚前,布置现场");
    	}
    	
    }
    

    总结:真实对象和代理对象都要实现同一个接口,代理对象要代理真是角色

    ​ 优点:代理对象可以做很多真实对象不能做的事情

    ​ 真实对象专注自己的事情

    结合线程来看:

    new Thread(t).start();

    new WeddingCompany(new You()).happyMarry();

    Runnable ——> Marry 接口

    Thread ---->WeddingCompany 即代理

    t ——> new You() 目标对象(真实角色)

    5.Lambda表达式

    • 实质属于函数式编程的概念
    1.作用
    • 避免匿名内部类定义过多
    • 使代码看起来简介
    • 简化代码,只留下核心逻辑
    2.函数式接口

    定义:任何接口,如果只包含唯一一个抽象方法,那么它就是一个函数式接口

    public interface Runnable{

    ​ public abstract void run();

    }

    ​ 对于函数式接口,我们可以通过lambda表达式来创建该接口的对象

    3.lambda简单推导
    package com.lmr.practice;
    
    /**
     * 推导Lambda表达式
     * @author DELL
     *
     */
    public class TestLambda {
    
        //3.静态内部类
        static class Like2 implements Ilike{
    
            @Override
            public void lambda() {
                System.out.println("i like lambda2");
            }
        }
    
        public static void main(String[] args) {
            Ilike like = new Like();
            like.lambda();
    
            like = new Like2();
            like.lambda();
    
            //4.局部内部类
            class Like3 implements Ilike{
    
                @Override
                public void lambda() {
                    System.out.println("i like lambda4");
                }
            }
    
            like = new Like3();
            like.lambda();
    
            //5.匿名内部类
            like = new Ilike() {
    
                @Override
                public void lambda() {
                    System.out.println("i like lambda5");
                }
            };
    
            like.lambda();
    
    
            //6.用lambda简化
            like = ()->{
                System.out.println("i like lambda5");
    
            };
            like.lambda();
    
        }
    
    }
    
    //1.定义一个函数式接口
    interface Ilike{
        void lambda();
    }
    
    //2.实现类
    class Like implements Ilike{
    
        @Override
        public void lambda() {
            System.out.println("i like lambda");
    
        }
    
    }
    
    
    
    package com.lmr.practice;
    
    public class TestLambda2 {
    
            public static void main(String[] args) {
                ILove  love = null;
              //1.lambda表示简化
              love = (int a)->{
                     System.out.println("LOvee"+ a);
                 };
              
              //简化1:参数类型
                love = (a)->{
                    System.out.println("LOvee"+ a);
                };
                
                //简化2:简化括号
                love = a->{
                    System.out.println("LOvee"+ a);
                };
                
                //简化3:简化花括号
                love = a-> System.out.println("LOvee"+ a);
                
                 love.love(205);
            }
    
        }
    
    interface ILove{
        void love(int a);
    }
    
    
    

    总结:

    • lambda表达式只能有一行代码的情况下才能简化成为一行,如果有多行,那么就用代码块包裹。

    • lambda表达式的前提是接口为函数式接口。

    • 多个参数也可以去掉参数类型,要去掉就都去掉,必须加上括号。

    6.线程停止

    1.线程状态

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HttTlS1d-1601087409261)(E:\MD文件\图片\多线程\93F442D7FF7797CBF23C0EA225386CBD.png)] [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-288mwVOZ-1601087409270)(E:\MD文件\图片\多线程\6在这里插入图片描述
    D5B0F7FEF652585FFDF35B4308429F1.png)] 在这里插入图片描述

    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("run...Thread"+ i++);
            }
        }
        
        //2.设置一个公开的方法停止线程,转换标志位
        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==900){
                    //调用stop方法切换标志位,让线程停止
                    stop.stop();
                    System.out.println("线程停止了");
                }
            }
        }
    }
    
    

    7.线程休眠 - sleep()

    • sleep(时间)指定当前线程阻塞的毫秒数;
    • sleep存在异常InterruptedException;
    • sleep时间达到后线程进入就绪状态;
    • sleep可以模拟网络延时,倒计时等;
    • 每一个对象都有一个锁,sleep不会释放锁。
    例子1:模拟延时:TestThread
    模拟网络延时的作用:放大问题的发生性
    
    package com.lmr.practice;
    
    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    //模拟倒计时
    public class TestSleep2 {
    
        public static void main(String[] args) {
    //        try {
    //            tenDown();
    //        } catch (InterruptedException e) {
    //            e.printStackTrace();
    //        }
            //打印系统当前时间
            Date startTime = new Date(System.currentTimeMillis());  //获取系统当前时间
            while(true){
                try {
                    Thread.sleep(1000);
                    System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
                    startTime = new Date(System.currentTimeMillis());  //更新当前时间
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    
        public static void tenDown() throws InterruptedException {
            int num = 10;
            while(true){
                Thread.sleep(1000);
                System.out.println(num--);
                if(num<=0){
                    break;
                }
            }
        }
    }
    
    

    8.线程礼让 - yield()

    • 礼让线程,让当前正在执行的线程暂停,但不阻塞;
    • 将线程从运行状态转为就绪状态;
    • 让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()+"线程停止执行");
        }
    }
    
    
    

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eUlsb03C-1601087409276)(E:\MD文件\图片\多线程\image-20200925193212356.png)]

    9.线程强制执行 - join()

    • join合并线程,待此线程执行完后,再执行其它线程,其它线程阻塞;
    • 可以想象成插队
    public class TestJoin implements Runnable{
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                System.out.println("线程VIP来了"+i);
            }
        }
    
        public static void main(String[] args) throws InterruptedException {
            TestJoin testJoin = new TestJoin();
            Thread thread = new Thread(testJoin);
    
            //主线程
            for (int i = 0; i < 1000; i++) {
                if(i == 200){
                    thread.start();
                    thread.join(); //插队
                }
                System.out.println("main"+i);
                
            }
        }
    }
    
    

    10.观测线程状态

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wvxHwbSG-1601087409285)(E:\MD文件\图片\多线程\image-20200925195430517.png)]

    public class TestState {
    
        public static void main(String[] args) throws InterruptedException {
            Thread thread = new Thread(()->{
                for (int i = 0; i < 5; i++) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("///");
            });
    
            //观察状态
            Thread.State state = thread.getState();
            System.out.println(state);    //NEW
    
            //观察后启动
            thread.start();   //启动线程
            state = thread.getState();
            System.out.println();   //Run
    
            while(state != Thread.State.TERMINATED){  //只要线程不停止,就一直输出状态
                Thread.sleep(100);
                state = thread.getState();    //更新线程状态
                System.out.println(state);   //输出状态
                
                //thread.start();   报错,因为已经死亡的线程不能再启动
            }
        }
    }
    
    

    11.线程的优先级

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

    • 线程的优先级用数字表示,范围从1~10.

      • Thread.MIN_PRIORITY = 1;
      • Thread.MAX_PRIORITY = 10;
      • Thread.NORM_PRIORITY = 5;
    • 使用一下方法改变或获取优先级

      • ​ getPriority.setPriority(int xxx)
    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);
            Thread t6 = new Thread(myPriority);
    
            //先设置优先级,再启动
            t1.start();
    
            t2.setPriority(1);
            t2.start();
    
            t3.setPriority(4);
            t3.start();
    
            t4.setPriority(Thread.MAX_PRIORITY);
            t4.start();
    
    //        t5.setPriority(-1);   //Exception in thread "main" java.lang.IllegalArgumentException
    //        t5.start();
    //
    //        t6.setPriority(11);   //Exception in thread "main" java.lang.IllegalArgumentException
    //        t6.start();
    
        }
    
    }
    
    class MyPriority implements  Runnable{
    
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
        }
    }
    

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0jA2AWw3-1601087409292)(E:\MD文件\图片\多线程\image-20200925201525711.png)]

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

    12.守护线程

    • 线程分为用户线程守护线程
    • 虚拟机必须确保用户线程执行完毕 (如,main)
    • 虚拟机不用等待守护线程执行完毕 (如,后台记录操作日志,监控内存,垃圾回收……)
    //上帝守护你
    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);   //默认false表示是用户线程,正常的线程都是用户线程
    
            thread.start();  //上帝守护线程启动
    
            new Thread(you).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++) {
                System.out.println("你一生都开心的活着");
            }
            System.out.println("=====GoodBye World!======");
        }
    }
    

    13.线程同步机制

    并发:同一个对象多个线程同时操作 (如:上万人同时抢票)

    处理多线程问题时,多线程访问同一个对象(并发),并且某些线程还想修改这个对象。这时则需要线程同步。

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

    线程同步的形成条件:队列+锁

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rZT8Jz76-1601087409295)(E:\MD文件\图片\多线程\FF4EB4DDBE3959B6B6B451A8276FEC32.png)]

    19.三大不安全案例

    (1)买票
    //线程不安全 有负数
    public class UnsafeBuyTicket  implements  Runnable{
        //票数
        private int ticketNums = 10;
        boolean flag = true;  //外部停止方法
    
        @Override
        public void run() {
            while(flag){
               buy();
            }
        }
        
        public void  buy(){
            //判断是否有票
            if(ticketNums<=0){
                flag = false;
                return;
            }
            //模拟延时
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"-->拿到了第"+ticketNums-- +"票");
        }
    
        public static void main(String[] args) {
            UnsafeBuyTicket ticket = new UnsafeBuyTicket();
    
            new Thread(ticket,"小明").start();
            new Thread(ticket,"老师").start();
            new Thread(ticket,"黄牛").start();
        }
    
    }
    
    
    (2)不安全的银行
    public class UnsafeBank {
        public static void main(String[] args) {
            Account account = new Account(100,"基金");
            Drawing you = new Drawing(account,50,"你");
            Drawing wo = new Drawing(account,100,"wo");
    
            you.start();
            wo.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() {
            //判断有没有钱
            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);
        }
    }
    
    (3)不安全的集合
    public class UnsafeList {
        public static void main(String[] args) throws InterruptedException {
            List<String> list = new ArrayList<String>();
            for (int i = 0; i < 10000; i++) {
                new Thread(()->{
                   list.add(Thread.currentThread().getName());
                }).start();
            }
            Thread.sleep(3000);
            System.out.println(list.size());
        }
    }
    //输出:9999
    

    20.同步方法和同步方法块

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

    ​ 同步方法: public synchronized void method(int args) }

    ◆synchronized方法控制对“对象”的访问,每个对象对应一 把锁,每个synchronized方法都必须获得调用该方法的对象的锁才能执行,否则线程会阻塞,方法一旦执行,就独占该锁,直到该方法返回才释放锁,后面被阻塞的线程才能获得这个锁,继续执行。
    缺陷:若将一个大的方法申明为synchronized将会影响效率

    方法里需要修改的内容才需要锁,否则浪费资源

    ◆同步块: synchronized (Obj){}
    ◆Obj称之为同步监视器
    ◆Obj可以是任何对象,但是推荐使用共享资源作为同步监视器
    ◆同步方法中无需指定同步监视器,因为同步方法的同步监视器就是this , 就是这个对象本身,或者是class [反射中讲解]
    ◆同步监视器的执行过程
    1.第一个线程访问,锁定同步监视器,执行其中代码.
    2.第二个线程访问,发现同步监视器被锁定,无法访问.
    3.第一个线程访问完毕,解锁同步监视器
    4.第二个线程访问, 发现同步监视器没有锁,然后锁定并访问

    修改三个不安全案例为安全:

    1.买票

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-a35ABjXf-1601087409300)(E:\MD文件\图片\多线程\image-20200925212012124.png)]

    2.银行

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uknaa2ws-1601087409303)(E:\MD文件\图片\多线程\image-20200925212332926.png)]

    3.list

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HSLYaMCN-1601087409306)(E:\MD文件\图片\多线程\image-20200925212522773.png)]

    4.测试JUC安全集合
    public class TestJUC {
        public static void main(String[] args) {
            CopyOnWriteArrayList<String> copy = new CopyOnWriteArrayList<String>();
            for (int i = 0; i < 10000; i++) {
                new Thread(()->{
    
                        copy.add(Thread.currentThread().getName());
    
    
                }).start();
            }
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(copy.size());
        }
    }
    //输出:10000
    

    21.死锁

    1.定义

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

    //死锁:多个线程互相抱着对方需要的资源
    public class DeadLock {
    
        public static void main(String[] args) {
            Makeup m1 = new Makeup(0,"小黑");
            Makeup m2 = new Makeup(1,"小白");
    
            m1.start();
            m2.start();
        }
    }
    
    //口红
    class Lipstick{
    
    }
    
    //镜子
    class Mirror{
    
    }
    
    //化妆
    class Makeup extends Thread{
    
        //需要的资源只有一份,用static来保证只有一份
        static Lipstick lipstick = new Lipstick();
        static Mirror mirror = new Mirror();
    
        int choice;   //选择
        String name;   //使用化妆品的人
    
        public Makeup(int choice, String name) {
            this.choice = choice;
            this.name = name;
        }
    
        @Override
        public void run() {
            //化妆
            try {
                makeup();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //化妆,互相持有对方的锁,就是需要拿到对方的资源
        private  void makeup() throws InterruptedException {
            if(choice ==0){
                synchronized (lipstick){  //获得口红的锁
                    System.out.println(this.name+"获得口红的锁");
                    Thread.sleep(1000);
    
                    synchronized (mirror){  //一秒钟后想获得镜子的锁
                        System.out.println(this.name+"获得镜子的锁");
                    }
                }
            }else{
                synchronized (mirror){  //获得镜子的锁
                    System.out.println(this.name+"获得镜子的锁");
                    Thread.sleep(2000);
                    synchronized (lipstick) {  //两秒钟后想获得口红的锁
                        System.out.println(this.name + "获得口红的锁");
                    }
                }
            }
        }
    
    }
    

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5OCJFSdC-1601087409311)(E:\MD文件\图片\多线程\image-20200926082534700.png)]

    解决办法:把同步代码块拿出来,不两个人同时抱一把锁。

     private  void makeup() throws InterruptedException {
            if(choice ==0){
                synchronized (lipstick){  //获得口红的锁
                    System.out.println(this.name+"获得口红的锁");
                    Thread.sleep(1000);
                }
    //从同步代码块拿出来
                   synchronized (mirror){  //一秒钟后想获得镜子的锁
                    System.out.println(this.name+"获得镜子的锁");
                }
            }else{
                synchronized (mirror){  //获得镜子的锁
                    System.out.println(this.name+"获得镜子的锁");
                    Thread.sleep(2000);
                }
    //从同步代码块拿出来
                synchronized (lipstick) {  //两秒钟后想获得口红的锁
                    System.out.println(this.name + "获得口红的锁");
                }
            }
        }
    
    

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tEwc35Ze-1601087409314)(E:\MD文件\图片\多线程\image-20200926082949651.png)]

    2.死锁避免方法
    • 产生死锁的四个必要条件:
      • 互斥条件:一个资源每次只能被一个进程使用。
      • 请求与保持条件:一个进程因请求资源而阻塞时,对已获得的资源保持不放。
      • 不剥夺条件:进程已获得的资源,在未使用完之前不能强行剥夺。
      • 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。

    只要破坏其中一个。就可以避免死锁。

    22.LOCK

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

    不安全的买票例子说明:

    class TestLock2 implements Runnable {
    
        int ticketNums = 10;
    
        //定义Lock锁
        private final ReentrantLock lock = new ReentrantLock();
    
        @Override
        public void run() {
            while (true) {
                try {
                    lock.lock();  //加锁
                    if (ticketNums > 0) {
                        try {
                            Thread.sleep(200);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName() + "-->拿到了第" + ticketNums-- + "票");
                    } else {
                        break;
                    }
                }finally {
                    //解锁
                    lock.unlock();
                }
            }
        }
    }
    

    注意:如果需要抛出异常,unlock()需要写在finally{}块中

    synchronized与Lock对比

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

    23.线程协作 - 生产者消费者模式

    1.线程通信
    (1)应用场景:生产者和消费者问题

    ◆假设仓库中只能存放- -件产品,生产者将生产出来的产品放入仓库,消费者将仓库中产品取走消费.
    ◆如果仓库中没有产品,则生产者将产品放入仓库,否则停止生产并等待,直到仓库中的产品被消费者取走为止.
    ◆如果仓库中放有产品,则消费者可以将产品取走消费,否则停止消费并等待,直到仓库中再次放入产品为止.

    (2)分析

    这是一个线程同步问题,生产者和消费者共享同- -个资源,并且生产者和消费者之间相互依赖,互为条件.
    ◆对于生产者,没有生产产品之前,要通知消费者等待.而生产了产品之后又需要马上通知消费者消费
    ◆对于消费者,在消费之后,要通知生产者已经结束消费,需要生产新的产品以供消费.
    ◆在生产者消费者问题中,仅有synchronized是不够的
    ◆synchronized可阻止并发更新同一个共享资源,实现了同步
    ◆synchronized不能用来实现不同线程之间的消息传递(通信)

    (3)解决方式:

    并发协作模型“生产者/消费者模式”–>

    a.管程法

    ◆生产者:负责生产数据的模块(可能是方法,对象,线程,进程);
    ◆消费者:负责处理数据的模块(可能是方法,对象,线程,进程);
    ◆缓冲区:消费者不能直接使用生产者的数据,他们之间有个“缓冲区“
    生产者将生产好的数据放入缓冲区,消费者从缓冲区拿出数据

    //生产者
    class Productor extends  Thread{
        SynContainer container;
    
        public Productor(SynContainer container) {
            this.container = container;
        }
        //生产
        @Override
        public void run() {
            for (int i = 0; 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 = 0; 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(){
            //判断能否消费
            if(count == 0){
                //通等待生产者生产
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
    
            //如果可以消费。就取出产品
            count--;
           Chicken chicken = chickens[count];
    
            //可以通知生产者消费了
            this.notifyAll();
    
           return chicken;
        }
    }
    

    (代码不是很严谨,存在先消费后生产的问题)

    b.信号灯法
    //生产者--演员
    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();
            }
        }
    }
    
    //产品--节目
    class TV{
        //演员表演,观众等待  T
        //观众观看,演员等待  F
        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;
        }
    
    }
    

    24.线程池

    使用线程池
    ◆背景:经常创建和销毁、使用量特别大的资源,比如并发情况下的线程,对性能影响很大。
    ◆思路:提前创建好多个线程,放入线程池中,使用时直接获取,使用完放回池中。
    可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。
    ◆好处:
    提高响应速度(减少了创建新线程的时间)
    降低资源消耗(重复利用线程池中线程,不需要每次都创建)
    便于线程管理…
    corePoolSize: 核心池的大小
    maximumPoolSize:最大线程数
    keepAliveTime: 线程没有任务时最多保持多长时间后会终止

    ◆JDK 5.0起提供了线程池相关API: ExecutorService 和Executors
    ◆ExecutorService: 真正的线程池接口。常见子类ThreadPoolExecutor
    void execute(Runnable command) :执行任务/命令,没有返回值,一般用来执Runnable
    Future submit(Callable task):执行任务,有返回值,一般用来执行Callable
    void shutdown() :关闭连接池
    ◆Executors: 工具类、线程池的工厂类,用于创建并返回不同类型的线程池

    public class TestPool {
    
        public static void main(String[] args) {
            //1.创建服务,创建线程池
            ExecutorService service = Executors.newFixedThreadPool(10);  //参数为线程池大小
    
            //执行
            service.execute(new MyThread());
            service.execute(new MyThread());
            service.execute(new MyThread());
            service.execute(new MyThread());
    
            //2.关闭连接
            service.shutdown();
        }
    
    }
    
    class MyThread implements Runnable{
    
        @Override
        public void run() {
                System.out.println(Thread.currentThread().getName());
        }
    }
    

    his.flag = !this.flag;
    }

    }

    
    ### 24.线程池
    
    >使用线程池
    >◆背景:经常创建和销毁、使用量特别大的资源,比如并发情况下的线程,对性能影响很大。
    >◆思路:提前创建好多个线程,放入线程池中,使用时直接获取,使用完放回池中。
    >           可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。
    >◆好处:
    >          提高响应速度(减少了创建新线程的时间)
    >          降低资源消耗(重复利用线程池中线程,不需要每次都创建)
    >          便于线程管理....
    >                   corePoolSize: 核心池的大小
    >                   maximumPoolSize:最大线程数
    >                   keepAliveTime: 线程没有任务时最多保持多长时间后会终止
    >
    >◆JDK 5.0起提供了线程池相关API: ExecutorService 和Executors
    >◆ExecutorService: 真正的线程池接口。常见子类ThreadPoolExecutor
    >          void execute(Runnable command) :执行任务/命令,没有返回值,一般用来执Runnable
    >         <T> Future<T> submit(Callable<T> task):执行任务,有返回值,一般用来执行Callable
    >         void shutdown() :关闭连接池
    >◆Executors: 工具类、线程池的工厂类,用于创建并返回不同类型的线程池
    >
    
    ```java
    public class TestPool {
    
        public static void main(String[] args) {
            //1.创建服务,创建线程池
            ExecutorService service = Executors.newFixedThreadPool(10);  //参数为线程池大小
    
            //执行
            service.execute(new MyThread());
            service.execute(new MyThread());
            service.execute(new MyThread());
            service.execute(new MyThread());
    
            //2.关闭连接
            service.shutdown();
        }
    
    }
    
    class MyThread implements Runnable{
    
        @Override
        public void run() {
                System.out.println(Thread.currentThread().getName());
        }
    }
    
    展开全文
  • 狂神说多线程笔记整理

    千次阅读 2021-02-16 13:29:26
    狂神说多线程笔记整理 笔记总结来自狂神说Java多线程详解 目录狂神说多线程笔记整理一、线程简介1.多任务2.多线程3.程序.进程.线程4.Process与Thread5.核心概念二、线程实现1.线程创建(三种方法)1.1继承Thread类...

    狂神说多线程笔记整理

    笔记总结来自狂神说Java多线程详解

    一、线程简介

    1.多任务

    多任务
    现实中太多这样同时做多件事情的例子了,看起来是多个任务都在做,其实本质上我们的大脑在同一时间依旧只做了一件事情。

    2.多线程

    多线程
    原来是一条路,慢慢因为车太多了,道路阻塞,效率极低。为了提高使用的效率,能够充分利用道路,于是加了多个车道。从此,妈妈再也不用担心道路阻塞了。
    普通方法调用和多线程

    3.程序.进程.线程

    在这里插入图片描述

    4.Process与Thread

    • 说起进程,就不得不说下程序。程序是指令和数据的有序集合,其本身没有任何运行的含义,是一个静态的概念。

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

    • 通常在一个进程中可以包含若干个线程,当然一个进程中至少有一个线程,不然没有存在的意义。线程是CPU调度和执行的单位。

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

    5.核心概念

    • 线程就是独立的执行路径
    • 在程序运行时,即使没有自己创建线程,后台也会有多个线程,比如主线程,GC线程
    • main()称之为主线程,为系统的入口,用于执行整个程序
    • 在一个进程中,如果开辟了多个线程,线程的运行是由调度器(cpu)安排调度的,调度器是与操作系统紧密相关的,先后顺序是不能人为干预的
    • 对同一份资源操作时mm会存在资源抢夺的问题,需要加入并发控制
    • 线程会带来额外的开销,如CPU调度时间,并发控制开销
    • 每个线程在自己的工作内存交互,内存控制不当会造成数据不一致

    二、线程实现

    1.线程创建(三种方法)

    1.1继承Thread类(重要)

    自定义线程类继承Thread

    重写run()方法,编写线程执行体

    创建线程对象,调用start()方法启动线程

    实现

    public class Demo1_CreateThread1 extends Thread {
        @Override
        public void run() {
            //run方法线程体
            for (int i = 0; i < 20; i++) {
                System.out.println("我在看代码----" + i);
            }
        }
    
        public static void main(String[] args) {
            //main线程,上线程
            //创建一个线程对象
            Demo1_CreateThread1 testThread = new Demo1_CreateThread1();
            //调用start()开启线程
            testThread.start();
            for (int i = 0; i < 200; i++) {
                System.out.println("我在学习多线程----" + i);
            }
        }
    }
    

    总结:

    线程不一定立即执行,CPU安排调度
    案例:(下载图片)

    案例

    /**
     * 练习Thread,实现多线程同步下载图片
     */
    public class Demo2_DownloaderImgCase extends Thread {
        private String url;//网络图片地址
        private String name;//报错扥文件名
    
        //有参构造
        public Demo2_DownloaderImgCase(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) {
            Demo2_DownloaderImgCase t = new Demo2_DownloaderImgCase("https://img-home.csdnimg.cn/images/20201124032511.png", "1.png");
            Demo2_DownloaderImgCase t1 = new Demo2_DownloaderImgCase("https://img-home.csdnimg.cn/images/20201124032511.png", "2.png");
            Demo2_DownloaderImgCase t2 = new Demo2_DownloaderImgCase("https://img-home.csdnimg.cn/images/20201124032511.png", "3.png");
            t.start();
            t1.start();
            t2.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方法出现问题");
            }
        }
    }
    

    1.2实现Runnable接口

    推荐使用Runnable对象,因为Java单继承的局限性

    自定义线程类实现Runnable接口

    实现run()方法,编写线程执行体

    创建线程对象,调用start()方法启动对象

    实现

    public class Demo3_CreateRunnable implements Runnable {
    
        @Override
        public void run() {
            //run方法线程体
            for (int i = 0; i < 20; i++) {
                System.out.println("我在看代码----" + i);
            }
        }
    
        public static void main(String[] args) {
            //创建runnable接口的实现类对象
            Demo3_CreateRunnable testThread = new Demo3_CreateRunnable();
            //创建线程对象,通过线程对象来开启我们的线程,代理
            Thread thread = new Thread(testThread);
            //调用start()开启线程
            thread.start();
    
            //new Thread(testThread).start();
            for (int i = 0; i < 200; i++) {
                System.out.println("我在学习多线程----" + i);
            }
        }
    }
    

    案例

    火车票:

    /**
     * 多个线程同时操作同一个对象  买火车票案例
     */
    //发现问题:多个线程操作同一个资源的情况下,线程不安全,数据紊乱
    public class Demo4_TrainTicketsCase implements Runnable {
    
        //票数
        private int ticketNums = 10;
    
        @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) {
            Demo4_TrainTicketsCase ticket = new Demo4_TrainTicketsCase();
            new Thread(ticket, "小红").start();
            new Thread(ticket, "老师").start();
            new Thread(ticket, "黄牛1").start();
            new Thread(ticket, "黄牛2").start();
        }
    }
    

    龟兔赛跑:

    在这里插入图片描述

    /**
     * 模拟龟兔赛跑
     */
    public class Demo5_RaceCase implements Runnable {
        //胜利者
        private static String winner;
    
        @Override
        public void run() {
            for (int i = 0; i <= 100; i++) {
                //模拟兔子休息
                if (Thread.currentThread().getName().equals("兔子") && i % 10 == 0) {
                    try {
                        Thread.sleep(2);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //判断比赛是否结束
                boolean flag = gameOver(i);
                //如果比赛结束,停止程序
                if (flag) {
                    break;
                }
                System.out.println(Thread.currentThread().getName() + "--->跑了" + i + "步");
            }
        }
    
        //判断是否完成
        private boolean gameOver(int steps) {
            if (winner != null) {
                return true;
            } else {
                if (steps >= 100) {
                    winner = Thread.currentThread().getName();
                    System.out.println("winner is " + winner);
                    return true;
                }
            }
            return false;
        }
    
        public static void main(String[] args) {
            Demo5_RaceCase race = new Demo5_RaceCase();
            new Thread(race, "兔子").start();
            new Thread(race, "乌龟").start();
        }
    }
    

    1.3实现Callable接口(了解)

    实现Callable接口,需要返回值类型

    重写call方法,需要抛出异常

    创建目标对象

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

    提交执行:Future result1 = ser.submit(11);

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

    关闭服务:ser.shutdownNow();

    实现

    /**
     * 实现Callable接口
     */
    public class Demo6_CreateCallable implements Callable<Boolean> {
    
        private String url;//网络图片地址
        private String name;//报错扥文件名
    
        //有参构造
        public Demo6_CreateCallable(String url, String name) {
            this.url = url;
            this.name = name;
        }
    
        //下载图片线程的执行体
        public Boolean call() throws Exception {
            WebDownloader webDownloader = new WebDownloader();
            webDownloader.downloader(url, name);
            System.out.println("下载了文件名为:" + name);
            return true;
        }
    
        public static void main(String[] args) throws ExecutionException, InterruptedException {
            Demo6_CreateCallable c = new Demo6_CreateCallable("https://img-home.csdnimg.cn/images/20201124032511.png", "1.png");
            Demo6_CreateCallable c1 = new Demo6_CreateCallable("https://img-home.csdnimg.cn/images/20201124032511.png", "2.png");
            Demo6_CreateCallable c2 = new Demo6_CreateCallable("https://img-home.csdnimg.cn/images/20201124032511.png", "3.png");
            //创建执行服务
            ExecutorService ser = Executors.newFixedThreadPool(3);
            //提交执行
            Future<Boolean> r = ser.submit(c);
            Future<Boolean> r1 = ser.submit(c1);
            Future<Boolean> r2 = ser.submit(c2);
            //获取结果
            boolean res = r.get();
            boolean res1 = r1.get();
            boolean res2 = r2.get();
            //关闭服务
            ser.shutdownNow();
        }
    }
    //class WebDownloader在前面下载图片已经定义了,这里就不用再次写,直接使用就好
    

    好处

    可以定义返回值

    可以抛出异常

    1.4Thread和Runnable对比

    继承Thred类:

    • 子类继承Thread类具备多线程能力
    • 启动线程:子类对象.start()
    • 不建议使用:避免OOP单继承局限性

    实现Runnable接口

    • 实现接口Runnable具有多线程能力

    • 启动线程:传入目标对象+Thread对象.start()

    • 推荐使用:避免单继承局限性,灵活方便,方便同一个对象被多个线程使用
      在这里插入图片描述

    2.静态代理

    在这里插入图片描述

    实现: 结婚案例

    /**
     * 静态代理:结婚案例
     */
    public class Demo7_StaticProxy {
        public static void main(String[] args) {
            WeddingCompany weddingCompany = new WeddingCompany(new You());
            weddingCompany.happyMarry();
        }
    }
    
    //结婚
    interface Marry {
        void happyMarry();
    }
    
    //真实角色:你去结婚
    class You implements Marry {
        @Override
        public void happyMarry() {
            System.out.println("doris要结婚了,超开心");
        }
    }
    
    //代理角色:帮助你结婚
    class WeddingCompany implements Marry {
        private Marry target;//代理-->真实目标角色角色,帮谁结婚
    
        public WeddingCompany(Marry target) {
            this.target = target;
        }
    
        @Override
        public void happyMarry() {
            after();
            this.target.happyMarry();
            before();
        }
    
        private void after() {
            System.out.println("结婚之前,布置现场");
        }
    
        private void before() {
            System.out.println("结婚之后,收尾款");
        }
    }
    

    优化:使用线程,Lamda表达式

    /**
     * 线程中的代理模式
     */
    public class Demo8_StaticProxy {
        public static void main(String[] args) {
            new Thread(()-> System.out.println("我爱你")).start();
            new WeddingCompany(new You()).happyMarry();
        }
    }
    //WeddingCompany...上一个文件定义过了这里就直接使用了
    

    总结

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

    好处

    代理对象可以做很多真实对象做不了的事情
    真实对象专注做自己的事

    3.Lamda表达式

    介绍

    在这里插入图片描述

    • λ 希腊字母表中排序第十一位的字母,英语名称为 Lamda
    • 避免匿名内部类定义过多
    • 其实质属于函数式编程的概念
    • 去掉了一堆没有意义的代码,只留下核心逻辑

    (params)-> expression[表达式]

    (params) -> statement[语句]

    [(params)-> {statements}

    a -> System.out.println("i like lamda-->"+a)
    

    new Thread (()->System.out.println(“多线程学习。。。。”)).start();

    理解Functional Interface (函数式接口) 是学习Java8 lamda表达式的关键

    函数式接口的定义:

    ​ 任何接口,如果只包含唯一一个抽象方法,那么它就是一个函数式接口.

    public interface Runnable{
        public abstract void run();
    }
    

    ​ 对于函数式接口,我们可以通过Lamda表达式来创建该接口的对象.

    实现:

    案例1:

    /**
     * 推导lamda表达式
     */
    public class Demo9_Lamda {
        public static void main(String[] args) {
            ILike like = new Like();
            like.lamda();
        }
    }
    
    // 1.定义一个函数式接口
    interface ILike {
        void lamda();
    }
    
    // 2.实现类
    class Like implements ILike {
        @Override
        public void lamda() {
            System.out.println("I like lamda");
        }
    }
    
    

    优化1:

    public class Demo10_Lamda1 {
        //3. 静态内部类
        static class Like1 implements ILike {
            @Override
            public void lamda() {
                System.out.println("I like lamda1");
            }
        }
        //3.静态内部类
        public static void main(String[] args) {
            ILike like = new Like1();
            like.lamda();
        }
    }
    

    优化2:

    public class Demo11_Lamda2 {
        public static void main(String[] args) {
            //4.局部内部类
            class Like12 implements ILike {
                @Override
                public void lamda() {
                    System.out.println("I like lamda2");
                }
            }
            ILike like = new Like12();
            like.lamda();
        }
    }
    

    优化3:

    public class Demo12_Lamda3 {
        public static void main(String[] args) {
            //5.匿名内部类,没有类的名称,必须借助接口或者父类
            ILike like = new ILike () {
                @Override
                public void lamda() {
                    System.out.println("I like lamda3");
                }
            };
            like.lamda();
        }
    }
    

    最终版:

    public class Demo13_Lamda4 {
        public static void main(String[] args) {
            //6.lamda简化
            ILike like = () ->{
                System.out.println("I like lamda4");
            };
            like.lamda();
        }
    }
    

    案例2:

    public class Demo14_LamdaCase2 {
        public static void main(String[] args) {
            // 1.lamda
            ILove love = (int a) -> {
                System.out.println("I love you -->" + a);
            };
            // 2.lamda简化1.0
            love = (a) -> {
                System.out.println("I love you -->" + a);
            };
            // 3.lamda简化2.0
            love = a -> {
                System.out.println("I love you -->" + a);
            };
            // 3.lamda简化3.0
            love = a -> System.out.println("I love you -->" + a);
    
            /**总结:
             * {}简略的条件是只能有一行代码,多行{}就不能简略了
             * 前提是接口为函数式接口(只能有一个方法)
             * 多个参数也可以去掉参数类型,要去掉就都去掉,必须加上()
             */
    
            love.love(520);
        }
    }
    
    interface ILove {
        void love(int a);
    }
    

    三、线程状态

    1.线程五大状态:

    在这里插入图片描述
    在这里插入图片描述

    2.线程方法

    在这里插入图片描述

    2.1停止线程

    在这里插入图片描述

    案例:

    /**
     * 测试stop
     * 1.建议线程正常停止-->利用次数,不建议死循环
     * 2.建议使用标志位-->设置一个标志位
     * 3.不要使用stop或者destroy等过时或者JDK不建议使用的方法
     */
    public class Demo15_StopThread implements Runnable {
        // 1. 设置一个标志位
        private boolean flag = true;
    
        @Override
        public void run() {
            int i = 0;
            while (flag) {
                System.out.println("run...Thread" + i++);
            }
        }
    
        // 2. 设置一个公开的方法停止线程,转换标志位
        public void stop() {
            this.flag = false;
        }
    
        public static void main(String[] args) {
            Demo15_StopThread stop = new Demo15_StopThread();
            new Thread(stop).start();
            for (int i = 0; i < 1000; i++) {
                System.out.println("main..." + i);
                if (i == 900) {
                    //调用stop()切换标志位,让线程终止
                    stop.stop();
                    System.out.println("该线程停止了");
                }
            }
        }
    }
    
    

    2.2线程休眠

    在这里插入图片描述

    案例:

    /**
     * 模拟网络延迟:放大问题的发生性
     */
    public class Demo16_SleepThread implements Runnable {
    
        //票数
        private int ticketNums = 10;
    
        @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) {
            Demo4_TrainTicketsCase ticket = new Demo4_TrainTicketsCase();
            new Thread(ticket, "小红").start();
            new Thread(ticket, "老师").start();
            new Thread(ticket, "黄牛1").start();
        }
    }
    
    /**
     * 模拟倒计时
     */
    public class Demo17_SleepThread2 {
    
        public static void main(String[] args) {
            try {
                tenDown();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    
        //模拟倒计时
        public static void tenDown() throws InterruptedException {
            int num = 10;//10秒
            while (true) {
                Thread.sleep(1000);
                System.out.println(num--);
                if (num <= 0) {
                    break;
                }
            }
        }
    }
    
    /**
     * 每一秒获取当前时间
     */
    public class Demo18_SleepThread3 {
    
        public static void main(String[] args) {
            //获取系统当前时间
            Date startTime = new Date(System.currentTimeMillis());
            while (true) {
                try {
                    Thread.sleep(1000);
                    //更新系统时间
                    System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
                    startTime = new Date(System.currentTimeMillis());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    

    2.3线程礼让

    在这里插入图片描述

    案例:

    /**
     * 测试礼让线程
     * 礼让不一定成功,看cpu心情
     */
    public class Demo19_YieldThread {
        public static void main(String[] args) {
            MyYeild myYeild = new MyYeild();
            new Thread(myYeild, "a").start();
            new Thread(myYeild, "b").start();
        }
    }
    
    class MyYeild implements Runnable {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + "线程开始执行");
            Thread.yield();//礼让
            System.out.println(Thread.currentThread().getName() + "线程停止执行");
        }
    }
    

    2.4线程插队

    在这里插入图片描述

    案例:

    /**
     * 测试join
     * 插队
     */
    public class Demo20_JoinThread implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 500; i++) {
                System.out.println("线程vip" + i);
            }
        }
    
        public static void main(String[] args) throws InterruptedException {
            //启动我们的线程
            Demo20_JoinThread joinThread = new Demo20_JoinThread();
            Thread thread = new Thread(joinThread);
            thread.start();
    
            //主线程
            for (int i = 0; i < 500; i++) {
                if (i == 200) {
                    thread.join();//插队
                }
                System.out.println("main" + i);
            }
        }
    }
    

    3.线程状态观测

    在这里插入图片描述

    实现:

    /**
     * 观察测试线程状态
     */
    public class Demo21_ThreadState {
        public static void main(String[] args) throws InterruptedException {
            Thread thread = new Thread(() -> {
                for (int i = 0; i < 5; i++) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("//");
            });
            //观察状态
            Thread.State state = thread.getState();
            System.out.println(state);
            //观察启动后
            thread.start();
            state = thread.getState();
            System.out.println(state);//Run
            while (state != Thread.State.TERMINATED) {//只要现成不终止,就一直输出状态
                Thread.sleep(100);
                state = thread.getState();//更新线程状态
                System.out.println(state);
            }
            //死亡后的线程不能再启动了,启动会报异常
            //thread.start();
        }
    }
    

    4.线程优先级

    在这里插入图片描述

    实现:

    /**
     * 线程优先级
     */
    public class Demo22_ThreadPriority{
        public static void main(String[] args) {
            //主线程默认优先级
            System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
    
            MyPriority myPriority = new MyPriority();
            Thread thread1 = new Thread(myPriority);
            Thread thread2 = new Thread(myPriority);
            Thread thread3 = new Thread(myPriority);
            Thread thread4 = new Thread(myPriority);
            Thread thread5 = new Thread(myPriority);
    
            //先设置优先级,再启动
            thread1.start();
    
            thread2.setPriority(1);
            thread2.start();
    
            thread3.setPriority(4);
            thread3.start();
    
            thread4.setPriority(Thread.MAX_PRIORITY);//MAX_PRIORITY=10
            thread4.start();
    
            thread5.setPriority(8);
            thread5.start();
        }
    }
    class MyPriority implements Runnable{
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
        }
    }
    

    5.守护(daemon)线程

    在这里插入图片描述

    实现:

    /**
     * 测试守护线程
     * 上帝守护你
     */
    public class Demo23_DaemonThread {
        public static void main(String[] args) {
            God god = new God();
            You you = new You();
    
            Thread thread = new Thread(god);
            //默认false表示是用户线程,正常的线程都是用户线程...
            thread.setDaemon(true);
            //上帝守护线程启动
            thread.start();
            //你 用户线程启动
            new Thread(you).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++) {
                System.out.println("你一生都开心的活着");
            }
            System.out.println("====goodbye!world====");
        }
    }
    

    四、线程同步

    1.介绍

    **多个线程操作同一个资源 **

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    2.不安全的线程案例

    //不安全买票
    public class Demo24_UnsafeBuyTicket {
        public static void main(String[] args) {
            BuyTicket buyTicket = new BuyTicket();
            new Thread(buyTicket, "张三").start();
            new Thread(buyTicket, "李四").start();
            new Thread(buyTicket, "王五").start();
        }
    }
    
    class BuyTicket implements Runnable {
        //票
        private int ticketNums = 10;
        boolean flag = true;
    
        @Override
        public void run() {
            //买票
            while (flag) {
                try {
                    buy();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    
        //买票
        private void buy() {
            //判断是否有票
            if (ticketNums <= 0) {
                flag = false;
                return;
            }
            //延迟
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
            //买票
            System.out.println(Thread.currentThread().getName() + "拿到" + ticketNums--);
        }
    }
    
    /**
     * 不安全的取钱
     */
    public class Demo25_UnsafeBank {
        public static void main(String[] args) {
            Account account = new Account(100, "结婚基金");
            Drawing you = new Drawing(account, 50, "展堂");
            Drawing girlfriend = new Drawing(account, 100, "sad");
            you.start();
            girlfriend.start();
        }
    }
    
    //账户
    class Account {
        int money;//余额
        String cardName;//卡名
    
        public Account(int money, String cardName) {
            this.money = money;
            this.cardName = cardName;
        }
    }
    
    //银行:模拟取款
    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() {
            //判断是否有钱
            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.cardName + "余额为:" + account.money);
            //this.getName()==Thread.currentThread().getName()
            System.out.println(this.getName() + "手里的钱:" + nowMoney);
        }
    }
    
    //线程不安全的集合
    public class Demo26_UnsafeList {
        public static void main(String[] args) {
            List<String> list = new ArrayList<String>();
            for (int i = 0; i < 1000; i++) {
                new Thread(()->{
                    list.add(Thread.currentThread().getName());
                }).start();
            }
            System.out.println(list.size());
        }
    }
    

    3.同步方法

    在这里插入图片描述
    在这里插入图片描述
    同步方法,锁的是this

    实现:

    //安全买票
    public class Demo27_SafeBuyTicket {
        public static void main(String[] args) {
            BuyTicket1 buyTicket = new BuyTicket1();
            new Thread(buyTicket, "张三").start();
            new Thread(buyTicket, "李四").start();
            new Thread(buyTicket, "王五").start();
        }
    }
    
    class BuyTicket1 implements Runnable {
        //票
        private int ticketNums = 10;
        boolean flag = true;
    
        @Override
        public void run() {
            //买票
            while (flag) {
                try {
                    buy();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    
        //synchronized 同步方法,锁的是this
        private synchronized void buy() {
            //判断是否有票
            if (ticketNums <= 0) {
                flag = false;
                return;
            }
            //延迟
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
            //买票
            System.out.println(Thread.currentThread().getName() + "拿到" + ticketNums--);
        }
    }
    

    4.同步块

    在这里插入图片描述
    锁的对象就是变量的量,需要增删改查的对象

    实现:

    /**
     * 安全的取钱 同步块
     */
    public class Demo28_SafeBank {
        public static void main(String[] args) {
            Account1 account = new Account1(100, "结婚基金");
            Drawing1 you = new Drawing1(account, 50, "展堂");
            Drawing1 girlfriend = new Drawing1(account, 100, "sad");
            you.start();
            girlfriend.start();
        }
    }
    
    //账户
    class Account1 {
        int money;//余额
        String cardName;//卡名
    
        public Account1(int money, String cardName) {
            this.money = money;
            this.cardName = cardName;
        }
    }
    
    //银行:模拟取款
    class Drawing1 extends Thread {
        Account1 account;//账户
        int drawingMoney;//取金额
        int nowMoney;//你手里的钱
    
        public Drawing1(Account1 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.cardName + "余额为:" + account.money);
                //this.getName()==Thread.currentThread().getName()
                System.out.println(this.getName() + "手里的钱:" + nowMoney);
            }
        }
    
    //线程安全的集合 同步块
    public class Demo29_SafeList {
        public static void main(String[] args) {
            List<String> list = new ArrayList<String>();
            for (int i = 0; i < 1000; i++) {
                new Thread(() -> {
                    synchronized (list) {
                        list.add(Thread.currentThread().getName());
                    }
                }).start();
            }
            try {
                Thread.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(list.size());
        }
    }
    

    JUC安全集合类型扩充

    //测试JUC安全类型的集合
    public class Demo30_ThreadJuc {
        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());
        }
    }
    

    5.死锁

    在这里插入图片描述

    案例:

    /**
     * 死锁:多个线程互相抱着对方需要的资源,然后形成僵持
     * 解决:一个锁只锁一个对象
     */
    class Demo31_DeadLock {
        public static void main(String[] args) {
            Makeup makeup = new Makeup(0, "灰姑娘");
            Makeup makeup1 = new Makeup(1, "白雪公主");
            makeup.start();
            makeup1.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();
            }
        }
    
        private void makeup() throws InterruptedException {
            if (choice == 0) {
                synchronized (lipstick) {//获得口红的锁
                    System.out.println(this.girlName + "获得口红的锁");
                    Thread.sleep(1000);
                    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 + "获得口红的锁");
                    }
                }
            }
        }
    }
    

    解决:

    /**
     * 死锁:多个线程互相抱着对方需要的资源,然后形成僵持
     * 解决:一个锁只锁一个对象
     */
    class Demo31_DeadLock {
        public static void main(String[] args) {
            Makeup makeup = new Makeup(0, "灰姑娘");
            Makeup makeup1 = new Makeup(1, "白雪公主");
            makeup.start();
            makeup1.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();
            }
        }
    
        private void makeup() throws InterruptedException {
            if (choice == 0) {
                synchronized (lipstick) {//获得口红的锁
                    System.out.println(this.girlName + "获得口红的锁");
                    Thread.sleep(1000);
                }
                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 + "获得口红的锁");
                }
            }
        }
    }
    

    死锁避免办法

    在这里插入图片描述

    6.Lock(锁)

    在这里插入图片描述
    在这里插入图片描述

    实现

    //测试Lock锁
    public class Demo32_ThreadLock {
        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 {
        int tickerNums = 10;
        //定义Lock锁
        private final ReentrantLock lock = new ReentrantLock();
    
        @Override
        public void run() {
            while (true) {
                //加锁
                try {
                    lock.lock();
                    if (tickerNums <= 0) {
                        break;
                    }
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(tickerNums--);
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    //解锁
                    lock.unlock();
                }
            }
        }
    }
    

    7.synchroized与Lock对比

    在这里插入图片描述

    五、线程通信问题

    生产者消费者模式的问题
    在这里插入图片描述

    1.线程通信方法

    在这里插入图片描述
    在这里插入图片描述

    2.线程通信问题解决方式

    在这里插入图片描述

    /**
     * 测试:生产者消费者模型-->利用缓冲区解决:管程法
     */
    public class Demo33_ThreadPC {
        public static void main(String[] args) {
            SynContainer synContainer = new SynContainer();
            new Producer(synContainer).start();
            new Consumer(synContainer).start();
        }
    }
    
    //生产者
    class Producer extends Thread {
        //容缓冲区
        SynContainer container;
    
        public Producer(SynContainer container) {
            this.container = container;
        }
    
        //生产
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                container.push(new Product(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 = 0; i < 100; i++) {
                System.out.println("消费了-->" + container.pop().id + "件产品");
            }
        }
    }
    
    //产品
    class Product {
        int id;//产品编号
    
        public Product(int id) {
            this.id = id;
        }
    }
    
    //缓冲区
    class SynContainer {
        //需要一个容器大小
        Product[] products = new Product[10];
        //容器计数器
        int count = 0;
    
        //生产者放入产品
        public synchronized void push(Product product) {
            //如果容器满了,需要等待消费者消费
            /*如果是if的话,假如消费者1消费了最后一个,这是index变成0此时释放锁被消费者2拿到而不是生产者拿到,这时消费者的wait是在if里所以它就直接去消费index-1下标越界,如果是while就会再去判断一下index得值是不是变成0了*/
            while (count == products.length) {
                //通知消费者消费,等待生产
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //如果没有满,需要丢入产品
            products[count] = product;
            count++;
            //通知消费者消费
            this.notifyAll();
        }
    
        //消费者消费产品
        public synchronized Product pop() {
            //判断是否能消费
            while (count <= 0) {
                //等待生产者生产
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //如果可以消费
            count--;
            Product product = products[count];
            //吃完了 通知生产者生产
            this.notifyAll();
            return product;
        }
    }
    

    在这里插入图片描述

    /**
     * 测试:生产者消费者模型-->利用缓冲区解决:管程法
     */
    public class Demo33_ThreadPC {
        public static void main(String[] args) {
            SynContainer synContainer = new SynContainer();
            new Producer(synContainer).start();
            new Consumer(synContainer).start();
        }
    }
    
    //生产者
    class Producer extends Thread {
        //容缓冲区
        SynContainer container;
    
        public Producer(SynContainer container) {
            this.container = container;
        }
    
        //生产
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                container.push(new Product(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 = 0; i < 100; i++) {
                System.out.println("消费了-->" + container.pop().id + "件产品");
            }
        }
    }
    
    //产品
    class Product {
        int id;//产品编号
    
        public Product(int id) {
            this.id = id;
        }
    }
    
    //缓冲区
    class SynContainer {
        //需要一个容器大小
        Product[] products = new Product[10];
        //容器计数器
        int count = 0;
    
        //生产者放入产品
        public synchronized void push(Product product) {
            //如果容器满了,需要等待消费者消费
            /*如果是if的话,假如消费者1消费了最后一个,这是index变成0此时释放锁被消费者2拿到而不是生产者拿到,这时消费者的wait是在if里所以它就直接去消费index-1下标越界,如果是while就会再去判断一下index得值是不是变成0了*/
            while (count == products.length) {
                //通知消费者消费,等待生产
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //如果没有满,需要丢入产品
            products[count] = product;
            count++;
            //通知消费者消费
            this.notifyAll();
        }
    
        //消费者消费产品
        public synchronized Product pop() {
            //判断是否能消费
            while (count <= 0) {
                //等待生产者生产
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //如果可以消费
            count--;
            Product product = products[count];
            //吃完了 通知生产者生产
            this.notifyAll();
            return product;
        }
    }
    

    六、线程池

    在这里插入图片描述
    在这里插入图片描述

    //测试线程池
    public class Demo35_ThreadPool {
        public static void main(String[] args) {
            // 1. 创建服务,擦行间线程池
            // newFixedThreadPool(线程池大小)
            ExecutorService service = Executors.newFixedThreadPool(10);
            //执行
            service.execute(new MyThread());
            service.execute(new MyThread());
            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());
        }
    }
    

    多线程笔记.md,练习项目链接

    笔记:
    链接:https://pan.baidu.com/s/1qwURET2GbIm10r6vWgNRkg
    提取码:tyui
    练习:
    链接:https://pan.baidu.com/s/1TvBAAOiQTrSIUvWcLssCfA
    提取码:tyui

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,420
精华内容 568
关键字:

狂神说多线程笔记