• Java多线程编程【一文全解】



    01 线程简介

    在这里插入图片描述
            普通的程序中,方法的调用是执行到方法的时候,程序跳转到方法体中进行,是按照顺序进行的,而多线程则是多任务“同时”进行,即“边吃饭边看电视”,而不是“吃完饭再看电视”,多线程是并发执行的。(并发:短时刻内交替执行,宏观上是“同时”执行的)

    • 程序是指令和数据的有序集合,是静态的存储;
    • 进程是执行程序的一次执行过程,是动态的执行,是系统资源分配的单位;
    • 一个进程可包含若干个线程,一个进程至少拥有一个线程,线程是CPU调度和执行的单位;

    可以这么理解:电脑上的QQ存储在硬盘中,是一个程序,当我们运行它的时候,它就成为了一个进程,得到了系统资源分配,而它的功能比如可以同时聊天同时打电话还可以逛空间和发邮件,这些诸多功能就是线程

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

    • 线程是独立的执行路径;
    • 在程序运行时,即使没有自己创建线程,后台也会有多个线程,如主线程,gc线程(垃圾回收);
    • 主线程即 main()函数,是系统的入口,用于执行整个程序;
    • 在一个进程中,如果开辟了多个线程,线程的运行由调度器安排调度,调度器是与操作系统紧密相关的,先后顺序由调度器(操作系统)就决定,无法干预;
    • 对同一份资源操作时,会存在资源抢夺问题,需要加入并发控制;
    • 线程会带来额外的开销,如CPU调度时间,并发控制开销;
    • 每个线程在自己的工作内存交互,内存控制不当会造成数据不一致;
    • 线程可以共享进程的资源,不必再单独分配,所以线程的引入提升了性能。

    Java虚拟机允许应用程序同时执行多个执行线程,每个线程都有优先权


    02 进程的创建

    进程的创建有如下三种方式:
    在这里插入图片描述

    > 继承 Thread 类

    • 自定义线程类继承 Thread 类

    • 重写 run( ) 方法,编写程序执行体;

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

    通过打印输出来判断多线程的执行顺序:

    //创建线程方式一:继承Thread类,重写run()方法,调用start()方法
    public class TestThread01 extends Thread{
        @Override
        public void run() {
            //run方法线程体
            for (int i = 0; i < 10; i++) {
                System.out.println("敲代码+"+i);
            }
        }
        
        public static void main(String[] args) {
            //main主线程
            
            //创建一个线程对象
            TestThread01 t1 = new TestThread01();
            
            //调用start()方法开启
            t1.start();
            
            for (int i = 0; i < 1000; i++) {
                System.out.println("学习Java+"+i);
            }
        }
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

    运行可知,并没有按顺序执行,而是并发执行的(由CPU调度执行):
    在这里插入图片描述

    > 实现 Runnable 接口

    • 定义 MyRunnable 类实现 Runnable 接口
    • 实现 run( ) 方法,编写线程执行体;
    • 创建线程对象,调用 start( ) 方法启动线程;

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

    //创建线程方式二:实现Runnable接口,重写run()方法,执行线程需要丢入Runnable接口实现类,调用start方法
    public class TestThread02 implements Runnable{
        @Override
        public void run() {
            //run方法线程体
            for (int i = 0; i < 10; i++) {
                System.out.println("敲代码+"+i);
            }
        }
        public static void main(String[] args) {
            //创建一个Runnable接口的实现类对象
            TestThread02 testThread02 = new TestThread02();
            /*
            创建线程对象,通过线程对象来开启线程
            Thread thread = new Thread(testThread02);
            thread.start();
             */
            new Thread(testThread02).start();
            
            for (int i = 0; i < 1000; i++) {
                System.out.println("学习Java+"+i);
            }
        }
    
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25

    在这里插入图片描述

    对比 继承Thread类实现Runnable接口 两种方法:在这里插入图片描述


    继承Thread类

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

    实现Runnable接口

    • 实现Runnable具有多线程能力;
    • 启动线程:传入目标对象+Thread对象.start( );
    • 推荐使用:避免单继承局限性,方便同一个对象被多个线程使用;

    > 实现 Callable 接口

    1. 实现Callable接口,需要返回值类型;
    2. 重写call方法,需要抛出异常;
    3. 创建目标对象;
    4. 创建执行服务:
      ExecutorService ser = Executors.newFixedThreadPool(1);
    5. 提交执行:Future result = ser.submit(thread01);
    6. 获取结果:boolean r1 = result.get();
    7. 关闭服务:ser.shutdownNow();
    //进程创建方式三:实现Callable接口
    public class TestCallable implements Callable<Boolean> {
        //重写call()方法
        @Override
        public Boolean call() throws Exception {
            System.out.println("方法体");
            return true;
        }
    
        public static void main(String[] args) throws Exception {
        	//创建对象
            TestCallable tc = new TestCallable();
    
            //创建执行服务
            ExecutorService ser = Executors.newFixedThreadPool(1);
    
            //提交执行
            Future<Boolean> result = ser.submit(tc);//通过服务提交线程
    
            //获取结果
            boolean b = result.get(); //call()方法返回类型
            
            //关闭服务
            ser.shutdown();
        }
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26

    Callable的好处:

    1. 可以定义返回值;
    2. 可以抛出异常;

    Lambda表达式 λ

    • Lambda表达式是一种特殊的表达语法,能够把一段代码像数据一样作为参数传递。> Lambda详解

    • 能够避免内部类定义过多;

    • 简化程序定义,只留下核心的逻辑,但会降低可读性;

    语法:

    (params) -> expression[表达式]
    (params) -> statement[语句]
    (params) -> {statements}
    
    • 1
    • 2
    • 3
    函数式接口的定义:
    	任何接口,如果只包含唯一一个抽象方法,那么它就是一个函数式接口;
    public interface Runnable{
    	public abstract void run();
    }
    	对于函数式接口,可以通过Lambda表达式来创建该接口的对象
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    常规定义:
    在这里插入图片描述

    也可以使用 静态内部类(在类里面定义) :

    在这里插入图片描述
    还可以 局部内部类 (定义在方法里)和 匿名内部类(没有类名):

    在这里插入图片描述

    终极大招: Lambda简化
    在这里插入图片描述
    继续深入理解 Lambda 表达式:
    在这里插入图片描述
    简化:
    前提是接口为函数式接口;
    多个参数也可以去掉参数类型;
    Lambda表达式只有在一行代码的情况下才能简化没有花括号;

    在这里插入图片描述

    相当于:
    在这里插入图片描述


    ※ 静态代理模式

    • 先定义一个接口;
    • 真实对象和代理对象都要实现同一个接口;
    • 代理对象要代理真实对象
    • (就是将真实对象作为参数传入代理对象的构造方法)
      • 代理对象可以做很多真实对象做不了的事;
      • 真实对象可以专注做自己的事;

    定义一个宠物类为真实对象,而主人类是代理对象,用主人类代理宠物类的方法:

    public class StaticProxy {
        public static void main(String[] args) {
            Master master = new Master(new Pet());
            master.play();
        }
    }
    
    interface Happy{
        //接口定义一个“玩”方法
        void play();
    }
    
    //真实角色 宠物
    class Pet implements Happy{
        @Override
        public void play() {
            System.out.println("拼命拼命耍");
        }
    }
    
    //代理角色 宠物的主人
    class Master implements Happy{
        //代理谁(代理的真实角色)
        private Happy who;
        public Master(Happy who){
            this.who = who;//真实对象
        }
        private void before() {
            System.out.println("带狗出门");
        }
        private void after() {
            System.out.println("回家给狗洗澡");
        }
        
        @Override
        public void play() {
            before();
            this.who.play();
            after();
        }
    }
    /*
    输出:
    	带狗出门
    	拼命拼命耍
    	回家给狗洗澡
    /*
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47

    对于 多线程 的应用:

    //创建一个Thread 静态代理Runnable接口
    new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("今天去哪里玩了呀")
                }
            }).start();
            
    等同于如下:(使用lambda表达式)
    //使用lambda表达式
    new Thread(()-> System.out.println("今天去哪里玩了呀")).start();
    
    1.Thread是代理角色;
    2.Runnable接口是真实角色;
    3.Thread也实现Runnable接口;
    3.所以Thread代理Runnable接口实现方法start();
    
    new Thread(()-> System.out.println("今天去哪里玩了呀")).start();
    
    相当于:
    
    new Master(new Pet()).play();
    
     ThreadMaster 都是代理对象
    RunnablePet 是真实对象
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25

    03 线程状态

    在这里插入图片描述

    线程有五大状态:

    • 创建状态 :new
    • 就绪状态 :start( )
    • 阻塞状态:sleep( ) wait( ) lock( ) synchronized( )
    • 运行状态:CPU调度执行
    • 死亡状态:线程终止
      在这里插入图片描述

    04 线程方法

    在这里插入图片描述

    > 停止线程 stop( )

    • 不建议使用JDK提供的 stop( )、destroy( ) 【已废弃】;
    • 建议 让线程自己停下来
    • 即:使用一个标志位进行终止变量,当 flag=false ,则终止线程运行;
    1. 建议线程正常停止,利用次数,不建议死循环;
    2. 建议使用标志位 flag 判断;
    3. 不要使用 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) {
            //创建Runnable实现类对象,通过线程对象开启线程
            TestStop testStop = new TestStop();
            new Thread(testStop).start();
    
            for (int i = 0; i < 1000; i++) {
                System.out.println("main线程 "+i);
                if (i==900){
                    //调用stop方法切换标志位,让线程停止
                    testStop.stop();
                    System.out.println("线程停止");
                }
            }
        }
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32

    > 线程休眠 sleep( )

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

    1 秒 = 1000 毫秒

    倒计时 10、9、8 … 2、1 :

    public class TestSleep implements Runnable {
        @Override
        public void run() {
            for (int i = 10; i > 0; i--) {
                System.out.println(i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }
        public static void main(String[] args) {
            TestSleep testSleep = new TestSleep();
            new Thread(testSleep).start();
        }
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    > 线程礼让 yield( )

    • 礼让线程,让当前正在执行的线程暂停,但不阻塞;
    • 将线程从 运行状态 为 就绪状态 ;
    • 让CPU重新调度,礼让不一定成功,看CPU心情;
    //测试礼让线程
    //礼让不一定成功,看CPU心情
    public class TestYield {
    
        public static void main(String[] args) {
            MyYield myYield = new MyYield();
            new Thread(myYield,"a").start();
            new Thread(myYield,"b").start();
        }
    }
    class MyYield implements Runnable{
        @Override
        public void run(){
            System.out.println(Thread.currentThread().getName()+"线程开始执行");
            Thread.yield();
            System.out.println(Thread.currentThread().getName()+"线程停止执行");
        }
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    运行结果如下(多种):


    > 线程强行执行 join( )

    • Join 合并线程,待此线程执行完成后,再执行其他线程,其他线程阻塞;
    • 可以理解为 “ 插队
    //测试join方法  相当于“插队”
    public class TestJoin implements Runnable{
        @Override
        public void run() {
            for (int i = 0; i < 1000; i++) {
                System.out.println("线程 BOSS 来啦"+i);
            }
        }
    
        public static void main(String[] args) throws InterruptedException {
            //启动线程
            TestJoin testJoin = new TestJoin();
            Thread thread = new Thread(testJoin);
            thread.start();
    
            //主线程
            for (int i = 0; i < 500; i++) {
                if(i==200){
                    thread.join();//线程插队
                }
                System.out.println("main "+i);
            }
        }
    } //如果子线程会穿插在主线程中,可以在run()中加个sleep()
    /*
    	main 0
    	main 1
    	...
    	main 198
    	main 199
    	线程 BOSS 来啦0
    	线程 BOSS 来啦1
    	线程 BOSS 来啦2
    	...
    	线程 BOSS 来啦998
    	线程 BOSS 来啦999
    	main 200
    	main 201
    	...
    	main 498
    	main 499
    */
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42

    > 线程状态观测 Thread.State

    在这里插入图片描述

    //观察线程状态
    public class TestState {
        public static void main(String[] args) throws InterruptedException {
            Thread thread = new Thread(()->{  //Lambda表达式
                for (int i = 0; i < 5; i++) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
                System.out.println("-------------");
            });
    
            //观察状态
            Thread.State state = thread.getState();
    
            //观察启动后
            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();
        }
    }
    /* 输出:
        RUNNABLE
        TIMED_WAITING
        TIMED_WAITING
        ......
        TIMED_WAITING
        -------------
        TERMINATED
     */
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40

    > 线程的优先级 Priority

    • Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程,线程调度器按照优先级决定应该调度哪个线程来执行;
    • 线程的优先级用数字表示,范围从 1 ~ 10 .
      • Thread.MIN_PRIORITY = 1 ;
      • Thread.MAX_PRIORITY = 10 ;
      • Thread.NORM_PRIORITY = 5 ;
    • 使用以下方法改变或获取优先级:
      • getPriority( )setPriority( int x)
    //测试线程的优先级
    public class TestPriority {
        public static void  main(String[] args ){
            //主线程默认优先级
            System.out.println(Thread.currentThread().getName()+"--->Priority  "+
                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);
            //先设置优先级,再启动
            t1.start();
    
            t2.setPriority(1);
            t2.start();
    
            t3.setPriority(4);
            t3.start();
    
            t4.setPriority(Thread.MAX_PRIORITY);//MAX_PRIORITY=10
            t4.start();
        }
    }
    class MyPriority implements Runnable{
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+
                    "--->Priority  "+Thread.currentThread().getPriority());
        }
    }
    /*
    main--->Priority  5
    Thread-0--->Priority  5
    Thread-3--->Priority  10
    Thread-2--->Priority  4
    Thread-1--->Priority  1
    
    进程已结束,退出代码0
     */
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41

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


    > 守护多线程 daemon

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

    守护线程是程序运行的时候在后台提供一种通用服务的线程。
    所有用户线程停止,进程才会停掉所有守护线程,退出程序。

    //测试守护线程
    //上帝守护你
    public class TestDaemon {
        public static void main(String[] args) {
            God god = new God();
            You you = new You();
    
            Thread thread = new Thread(god);
            thread.setDaemon(true);//默认是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 <--");
        }
    }  //可以自己运行一下,很有意思
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33

    05 线程同步机制

    • 多个线程操作同一个资源 ,例如:
      • 上万人同时抢100张票;
      • 两个银行同时取钱

    现实生活中,会遇到“同一个资源,多个人都想使用”的问题,例如:食堂排队打饭,每个人都想吃饭,最简单的解决办法就是,排队,一个一个来。

            处理多线程时,多个线程访问同一个对象,并且某些线程还想修改这个对象,这时候需要线程同步;线程同步其实就是一种 等待机制,多个需要同时访问此对象的线程进入到这个 对象的等待池 形成队列,等待前面线程使用完毕,下一个线程再使用。

    这个时候需要两种东西: 队列

    > 线程同步

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

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

    ※ 不安全案例

    01 不安全的买票

    线程不同步,可能会出现拿到 -1张票的情况

    //不安全的买票
    //线程不安全,会出现负数
    public class UnsafeBuyTicket {
        public static void main(String[] args){
            BuyTicket station = new BuyTicket();
    
            new Thread(station,"你").start();
            new Thread(station,"我").start();
            new Thread(station,"他").start();
        }
    }
    class BuyTicket implements Runnable{
        //票
        private int ticketNums = 10;
        boolean flag = true;//外部停止方式
        @Override
        public void run(){
            while(flag){
                try {
                    buy();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }
        private void buy() throws InterruptedException {
            //判断是否有票
            if(ticketNums <=0){
                flag = false;
                return;
            }
            //模拟延时
            Thread.sleep(100);
            //买票
            System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--);
        }
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37

    02 不安全的银行

    多个线程同时对银行发起取钱,会导致出现取多了的情况

    //不安全的取钱
    //两个人去银行取钱,账户
    public class UnsafeBank {
        public static void main(String[] args) {
            //账户
            Account account = new Account(100,"基金");
    
            Drawing you = new Drawing(account,50,"你");
            Drawing me = new Drawing(account,100,"我");
    
            you.start();
            me.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) {
                throw new RuntimeException(e);
            }
            //卡内余额 = 余额 - 取走的钱
            account.money = account.money - drawingMoney;
            //手里的钱
            nowMoney = nowMoney+ drawingMoney;
            System.out.println(account.name+"余额为"+account.money);
            //Thread.currentThread().getName() = this.getName;
            System.out.println(this.getName()+"手里的钱"+nowMoney);
        }
    } /*        基金余额为-50
                你手里的钱50
                基金余额为-50
                我手里的钱100
            
                进程已结束,退出代码0
    */
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64

    03 线程不安全的集合

    //线程不安全的集合
    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();
            }
            System.out.println(list.size());
        }
    }  /*   9997
    
            进程已结束,退出代码0
    */
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    > 同步方法及方法块

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

    • synchronized 方法 和 synchronized 块

    同步方法:

    public synchronized void method( int args){}
    
    • 1

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

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

    • 弊端:方法里面需要修改的内容才需要锁,锁的太多,浪费资源,这个时候就需要 同步块 来解决

    同步块:

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

    解决之前不安全的买票:(同步方法)

    //安全的买票
    public class UnsafeBuyTicket {
        public static void main(String[] args){
            BuyTicket station = new BuyTicket();
    
            new Thread(station,"你").start();
            new Thread(station,"我").start();
            new Thread(station,"他").start();
        }
    }
    
    class BuyTicket implements Runnable{
        //票
        private int ticketNums = 10;
        boolean flag = true;//外部停止方式
    
        @Override
        public void run(){
            while(flag){
                try {
                    buy();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    
        //synchronized 定义为同步方法,锁的是 this
        private synchronized void buy() throws InterruptedException {
            //判断是否有票
            if(ticketNums <=0){
                flag = false;
                return;
            }
            //模拟延时
            Thread.sleep(100);
            //买票
            System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--);
        }
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40

    解决不安全的银行:(同步块)

    //安全的取钱
    //两个人去银行取钱,账户
    public class UnsafeBank {
        public static void main(String[] args) {
            //账户
            Account account = new Account(100,"基金");
    
            Drawing you = new Drawing(account,50,"你");
            Drawing me = new Drawing(account,100,"我");
    
            you.start();
            me.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(){
        	//全部放到同步块中 监视account
            synchronized(account) {
                //判断有没有钱
                if(account.money-drawingMoney<0){
                    System.out.println(Thread.currentThread().getName()+"钱不够,取不了");
                    return;
                }
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                //卡内余额 = 余额 - 取走的钱
                account.money = account.money - drawingMoney;
                //手里的钱
                nowMoney = nowMoney+ drawingMoney;
    
                System.out.println(account.name+"余额为"+account.money);
                //Thread.currentThread().getName() = this.getName;
                System.out.println(this.getName()+"手里的钱"+nowMoney);
            }
        }           
    }/*     基金余额为50
            你手里的钱50
            我钱不够,取不了
    
            进程已结束,退出代码0
    */
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74

    解决不安全的集合:(同步块)

    //线程安全的集合
    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(()->{
                    synchronized (list){
                        list.add(Thread.currentThread().getName());
                    }
                }).start();
            }
            Thread.sleep(3000);
            System.out.println(list.size());
        }
    }  /*   10000
    
            进程已结束,退出代码0
    */
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    ※ 安全类型的集合 CopyOnWriteArrayList

    import java.util.concurrent.CopyOnWriteArrayList;
    //测试JUC安全类型的集合 CopyOnWriteArrayList
    public class UnsafeList {
        public static void main(String[] args) throws InterruptedException {
        
            CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();
            
            for (int i = 0; i < 10000; i++) {
                new Thread(()->{
                        list.add(Thread.currentThread().getName());
                }).start();
            }
            Thread.sleep(3000);
            System.out.println(list.size());
        }
    }  /*   10000
    
            进程已结束,退出代码0
    */
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    06 死锁

    什么是死锁?

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

            简单来说就是,甲需要乙手中的东西,而乙又想要甲手中的东西,两者陷入死循环,这就是死锁。

    例:有两个女生,一个是灰姑娘,一个是白雪公主,两人都想化妆,但一个有口红,一个有镜子,她们都互相想要对方手里的东西,陷入了僵持:这就是死锁

    //死锁:多个线程互相抱着对方需要的资源,然后形成僵持
    public class DeadLock {
        public static void main(String[] args) {
            Makeup girl1 = new Makeup(0,"灰姑娘");
            Makeup girl2 = new Makeup(1,"白雪公主");
    
            girl1.start();
            girl2.start();
        }
    }
    
    //口红
    class LipStick{}
    
    //镜子
    class Mirror{}
    
    class Makeup extends Thread{
        //需要的资源只有一份,用static来保证只有一份(不然不同对象的都不同)
        static LipStick lipstick = new LipStick();
        static Mirror mirror = new Mirror();
    
        int choice;//选择
        String name;//使用化妆品的人
    
        Makeup(int choice,String name){
            this.choice = choice;
            this.name = name;
        }
    
        @Override
        public void run() {
            //化妆
            try {
                makeup();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    
        //化妆,互相持有对方的锁,就是需要拿到对方的资源
        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+ "获得镜子的锁");
                        Thread.sleep(1000);
                    }
                }
            }else{
                synchronized(mirror){
                    System.out.println(this.name+"获得镜子的锁");
                    Thread.sleep(1000);
                    //一秒钟后获得锁
                    synchronized(lipstick){
                        System.out.println(this.name+"获得口红的锁");
                        Thread.sleep(1000);
                    }
                }
            }
        }
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65

    如何避免死锁?

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

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

    只要破其中的任意一个或多个条件就可以避免死锁发生

    Lock 锁

    • 从JDK5.0开始,Java提供了更强大的线程同步机制 —— 通过显示定义同步锁对象来实现同步;同步锁使用Lock对象充当;
    • java.util.concurrent.locks.Lock 接口是控制多个线程对共享资源进行访问的工具;
    • 锁提供了对共享资源的独占访问,每次只能有一个线程对 Lock 对象加锁,线程开始访问共享资源之前应该先获得 Lock 对象;
    • ReentrantLock 类实现了 Lock,它拥有与 synchronized 相同的并发性和内存语义,在实现线程安全的控制中,比较常见的是 ReentrantLock,可以显式加锁,释放锁;
    class Test{
    	private final ReentrantLock lock = new ReentrantLock();
    	public void method(){
    		lock.lock();
    		try{
    			//保证线程安全的代码
    		}finally{
    			lock.unlock();
    			//如果同步代码有异常,要将unlock()写入finally语句块
    		}
    	}
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    synchronized 与 Lock 的对比:

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

    先看不加锁的,运行结果发现输出结果有误:
    在这里插入图片描述
    然后用 ReentrantLock 加锁解锁 解决:

    //测试Lock锁
    public class TestLock {
        public static void main(String[] args) {
            TestLock2 t= new TestLock2();
            new Thread(t).start();
            new Thread(t).start();
            new Thread(t).start();
        }
    }
    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(1000);
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                        System.out.println(ticketNums--);
                    }else{
                        break;
                    }
                }finally {
                    //解锁
                    lock.unlock();
                }
    
            }
        }
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37

    07 线程协作

    生产者和消费者问题

    在这里插入图片描述

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

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

    • 对于生产者,没有生产产品之前,要通知生产者已经结束消费,需要生产新的品以供消费;
    • 对于消费者,在消费之后,要通知生产者已经结束消费,需要生产新的产品以供消费;
    • 在生产者消费者问题中,仅有 synchronized 是不够的;
      • synchronized 可阻止并发更新同一个资源,实现同步;
      • synchronized 不能用来实现不同线程之间的消息传递(线程通信)

    > 线程通信

    Java提供了几个方法解决线程之间的通信问题:

    在这里插入图片描述

    01 管程法

    并发协作模型:生产者消费者模式-----> 管程法(增加缓冲区)

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

    生产者将生产好的数据放入缓冲区,消费者从缓冲区拿出数据

    //测试:生产者消费者模型--->利用缓冲区解决:管程法
    //生产者,消费者,产品,缓冲区
    public class TestPC {
        public static void main(String[] args) {
            //创建一个容器
            SynContainer container = new SynContainer();
    
            new Producer(container).start();
            new Consumer(container).start();
        }
    }
    
    //生产者
    class Producer extends Thread{
        SynContainer container;
        public Producer(SynContainer container){
            this.container = container;
        }
        //生产
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                try {
                    container.push(new Food(i));
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                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++) {
                try {
                    System.out.println("消费了--->"+container.buy().id+"个好吃的");
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
    
    //产品
    class Food{
        int id;//产品编号
        
        public Food(int id) {
            this.id = id;
        }
    }
    
    //缓冲区
    class SynContainer{
        //需要一个容器大小
        Food[] foods = new Food[10];
        //容器计数器
        int count = 0 ;
        
        //生产者放入产品
        public synchronized void push(Food food) throws InterruptedException {
            //如果容器满了,就需要等待消费者消费
            if(count==foods.length){
                //通知消费者消费,生产者等待
                this.wait();
            }
            //如果没有满,就需要丢入产品
            foods[count]=food;
            count++;
    
            //可以通知消费者消费了
            this.notifyAll();
    
        }
    
        public synchronized Food buy() throws InterruptedException {
            //判断能否消费
            if(count==0){
                //等待生产者生产,消费者等待
                this.wait();
            }
            //如果可以消费
            count--;
            Food food = foods[count];
            //吃完了,通知生产者生产
            this.notifyAll();
            return food;
        }
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97

    02 信号灯法

    并发协作模型:生产者消费者模式-----> 信号灯法(设标志位)

    //测试生产者消费者问题2:信号灯法-->标志位解决
    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 = 0; i < 20; i++) {
                if(i%2==0){
                    try {
                        this.tv.play("快乐大本营播放中");
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }else{
                    System.out.println("广告时间。。。。");
                }
            }
        }
    }
    
    //消费者--->观众
    class Watcher extends Thread{
        TV tv;
        public Watcher(TV tv){
            this.tv = tv;
        }
    
        @Override
        public void run(){
            for (int i = 0; i < 20; i++) {
                try {
                    tv.watch();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
    
    
    //产品--->节目
    class TV{
        //演员表演,观众等待 T
        //观众观看,演员等待 F
        String program ;//表演节目
        boolean flag = true;
    
        //表演
        public synchronized void play(String program) throws InterruptedException {
            if(!flag){
                this.wait();
            }
            System.out.println("演员表演--> "+program);
            //通知观众观看
            this.notifyAll();//通知唤醒
            this.program = program;
            this.flag = !this.flag;
        }
        //观看
        public synchronized void watch() throws InterruptedException {
            if(flag){
                this.wait();
            }
            System.out.println("观看了"+program);
            //通知演员表演
            this.notifyAll();
            this.flag = !this.flag;
        }
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81

    08 线程池

    背景:经常创建和销毁、使用量特别大的资源,比如并发情况下的线程,对性能影响很大;

    思路:提前创建好多个线程,放入线程池中,使用时直接获取,使用完放回池中;

    好处:

    • 提高响应速度(减少了创建新线程的时间);
    • 降低资源消耗(重复利用线程池中线程,不需要每次都创建);
    • 便于线程管理:
      • corePoolSize :核心池的大小
      • maximumPoolSize :最大线程数
      • keepAliveTime :线程没有任务时最多保持多长时间后会终止

    使用线程池:

    • JDK5.0起提供了线程池相关的API:ExecutorServiceExecutors
    • ExecutorService :真正的线程池接口。常见子类 ThreadPoolExcecutor
      • void execute (Runnable command) :执行任务/命令,没有返回值,一般用来执行Runnable
      • Future submit(Callable task):执行任务,有返回值,一般用来执行Callable
      • void shutdown() :关闭线程池
    • Executors :工具类、线程池的工厂类,用于创建并返回不同类型的线程池
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    //测试线程池
    public class TestPool {
        public static void main(String[] args) {
            //1.创建服务,创建线程池
            //newFixedThreadPool 参数为线程池大小
            ExecutorService service = Executors.newFixedThreadPool(10);
    
            service.execute(new MyThread());
            service.execute(new MyThread());
            service.execute(new MyThread());
            service.execute(new MyThread());
            service.execute(new MyThread());
    
            //2.关闭链接
            service.shutdown();
        }
    }
    //线程类实现Runnable接口
    class MyThread implements Runnable{
        @Override
        public void run(){
                System.out.println(Thread.currentThread().getName());
        }
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27

    在这里插入图片描述

  • 相关阅读:
    连接数据库时遇到的bug1号
    R语言ggplot2可视化:使用ggpubr包的ggbarplot函数可视化柱状图、palette参数自定义不同水平柱状图边框以及填充的颜色
    Unity中全局光照GI的总结
    MyBatis的缓存问题
    Linux内核4.14版本——drm框架分析(14)——Atomic KMS 架构(struct drm_atomic_state)
    20221106 今天的世界发生了什么
    web前端三大主流框架
    电力安全事故安全培训3D仿真展馆绿色环保持久复用
    Integritee通过XCM集成至Moonriver,为其生态系统带来企业级隐私解决方案
    OpenCV技术应用(4)— 如何改变图像的透明度
  • 原文地址:https://blog.csdn.net/Lov1_BYS/article/details/128007355