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

墨蓝 2023-09-23 16:19 36阅读 0赞

### 文章目录 ###

*  01 线程简介
 *  02 进程的创建
 *   *  > 继承 Thread 类
     *  > 实现 Runnable 接口
     *  > 实现 Callable 接口
 *  ※ Lambda表达式 λ
 *  ※ 静态代理模式
 *  03 线程状态
 *  04 线程方法
 *   *  > 停止线程 stop( )
     *  > 线程休眠 sleep( )
     *  > 线程礼让 yield( )
     *  > 线程强行执行 join( )
     *  > 线程状态观测 Thread.State
     *  > 线程的优先级 Priority
     *  > 守护多线程 daemon
 *  05 线程同步机制
 *   *  > 线程同步
     *  ※ 不安全案例
     *   *  01 不安全的买票
         *  02 不安全的银行
         *  03 线程不安全的集合
     *  > 同步方法及方法块
     *  ※ 安全类型的集合 CopyOnWriteArrayList
 *  06 死锁
 *   *   *  什么是死锁？
         *  如何避免死锁？
     *  Lock 锁
 *  07 线程协作
 *   *  生产者和消费者问题
     *  > 线程通信
     *  01 管程法
     *  02 信号灯法
 *  08 线程池

--------------------

# 01 线程简介 #

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

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

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

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

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

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

--------------------

# 02 进程的创建 #

进程的创建有如下三种方式：  
![在这里插入图片描述][466e26fb9e374a6eb36704b7a1329cf8.png]

## > 继承 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);
            }
        }
    }

运行可知，并没有按顺序执行，而是并发执行的（由CPU调度执行）：  
![在这里插入图片描述][f6cc959bfb4e47c499dafd3b51031249.png]

## > 实现 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);
            }
        }
    
    }

![在这里插入图片描述][71b56b11d42c48e6a080b0754bd6b61c.png]

> 对比 **继承Thread类** 和 **实现Runnable接口** 两种方法：![在这里插入图片描述][d0ee15e94c0f4f7e8ba88085b906c56e.png]
> 
> --------------------
> 
> **继承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();
        }
    }

> Callable的好处：
> 
> 1.  可以定义返回值；
> 2.  可以抛出异常；

--------------------

# ※ Lambda表达式 λ #

*  Lambda表达式是一种特殊的表达语法，能够把一段代码像数据一样作为参数传递。[> Lambda详解][Lambda]
 *  能够避免内部类定义过多；
 *  简化程序定义，只留下核心的逻辑，但会降低可读性；

语法：

(params) -> expression[表达式]
    (params) -> statement[语句]
    (params) -> {
        statements}

函数式接口的定义：
    	任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口；
    public interface Runnable{
        
    	public abstract void run();
    }
    	对于函数式接口，可以通过Lambda表达式来创建该接口的对象

常规定义：  
![在这里插入图片描述][2a4fa76ffbcc48dead25801b225d0996.png]

也可以使用 **静态内部类**（在类里面定义） ：

![在这里插入图片描述][64945fade6764984af064eee0c7c81de.png]  
还可以 **局部内部类** （定义在方法里）和 **匿名内部类**（没有类名）：

![在这里插入图片描述][cf4ffed07cb84d769414b7a1ffbcd7c8.png]

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

![在这里插入图片描述][97196c61949842978a19e85ac55afdd2.png]

相当于：  
![在这里插入图片描述][ece44cfcd9b746e792ada64b5c74514a.png]

--------------------

# ※ 静态代理模式 #

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

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

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();
        }
    }
    /*
    输出：
    	带狗出门
    	拼命拼命耍
    	回家给狗洗澡
    /*

对于 多线程 的应用：

//创建一个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();
    
     Thread  和 Master 都是代理对象
    Runnable 和 Pet 是真实对象

--------------------

# 03 线程状态 #

![在这里插入图片描述][773d58c63b4f42f2ac9a5c5753a656be.png]

**线程有五大状态:**

*  **创建状态** ：new
 *  **就绪状态** ：start( )
 *  **阻塞状态**：sleep( ) wait( ) lock( ) synchronized( )
 *  **运行状态**：CPU调度执行
 *  **死亡状态**：线程终止  
    ![在这里插入图片描述][2200b185d1c445f881d50e6836f7e814.png]

# 04 线程方法 #

![在这里插入图片描述][1b5a4c51203143ab93415bee34ffc41c.png]

## > 停止线程 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("线程停止");
                }
            }
        }
    }

## > 线程休眠 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();
        }
    }

## > 线程礼让 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()+"线程停止执行");
        }
    }

运行结果如下（多种）:

![7a286ca543ac42f7b93589fc98f6b51b.png][] ![5576a02438d0478fa683d4be833211ed.png][] ![7cf62d4a70594bf783e9f84f6a438371.png][]

--------------------

## > 线程强行执行 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
    */

## > 线程状态观测 Thread.State ##

![在这里插入图片描述][3b75da5afcb84324912c7f7af7c17228.png]

//观察线程状态
    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
     */

## > 线程的优先级 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
     */

> **优先级低只是意味着获得调度的概率低，并不是优先级低就不会被调用，都是看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 <--");
        }
    }  //可以自己运行一下，很有意思

--------------------

# 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--);
        }
    }

### 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
    */

### 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
    */

## > 同步方法及方法块 ##

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

*  **synchronized 方法 和 synchronized 块**

**同步方法：**

public synchronized void method( int args){
        }

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--);
        }
    }

**解决不安全的银行：（同步块）**

//安全的取钱
    //两个人去银行取钱，账户
    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
    */

**解决不安全的集合：（同步块）**

//线程安全的集合
    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
    */

--------------------

## ※ 安全类型的集合 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
    */

--------------------

# 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.  循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系；

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

## 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语句块
    		}
    	}
    }

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

先看不加锁的，运行结果发现输出结果有误：  
![在这里插入图片描述][e8baf983f6c94ff3a53b4ded73cb4e42.png]  
然后用 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();
                }
    
            }
        }
    }

--------------------

# 07 线程协作 #

## 生产者和消费者问题 ##

![在这里插入图片描述][67dfbd4777ea4833b3ae75fcd221c5e9.png]

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

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

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

## > 线程通信 ##

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

![在这里插入图片描述][065ca914384e415e9a53aaac066cf997.png]

## 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;
        }
    }

## 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;
        }
    }

--------------------

# 08 线程池 #

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

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

好处：

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

**使用线程池：**

*  JDK5.0起提供了线程池相关的API：**ExecutorService** 和 **Executors**
 *  **ExecutorService** ：真正的线程池接口。常见子类 ThreadPoolExcecutor
    
     *  void execute (Runnable command) ：执行任务/命令，没有返回值，一般用来执行Runnable
     *  <T>Future<T> submit(Callable<T> 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());
        }
    }

![在这里插入图片描述][4bf168c0ee1a4782b227d45a68180e82.png]

[e4ff7fe855d64b3fb92734a2610f5321.jpeg]: https://img-blog.csdnimg.cn/e4ff7fe855d64b3fb92734a2610f5321.jpeg
[466e26fb9e374a6eb36704b7a1329cf8.png]: https://img-blog.csdnimg.cn/466e26fb9e374a6eb36704b7a1329cf8.png
[f6cc959bfb4e47c499dafd3b51031249.png]: https://img-blog.csdnimg.cn/f6cc959bfb4e47c499dafd3b51031249.png
[71b56b11d42c48e6a080b0754bd6b61c.png]: https://img-blog.csdnimg.cn/71b56b11d42c48e6a080b0754bd6b61c.png
[d0ee15e94c0f4f7e8ba88085b906c56e.png]: https://img-blog.csdnimg.cn/d0ee15e94c0f4f7e8ba88085b906c56e.png
[Lambda]: https://blog.csdn.net/huangjhai/article/details/107110182
[2a4fa76ffbcc48dead25801b225d0996.png]: https://img-blog.csdnimg.cn/2a4fa76ffbcc48dead25801b225d0996.png
[64945fade6764984af064eee0c7c81de.png]: https://img-blog.csdnimg.cn/64945fade6764984af064eee0c7c81de.png
[cf4ffed07cb84d769414b7a1ffbcd7c8.png]: https://img-blog.csdnimg.cn/cf4ffed07cb84d769414b7a1ffbcd7c8.png
[52dce3af300246199ac666a2af37d5ce.png]: https://img-blog.csdnimg.cn/52dce3af300246199ac666a2af37d5ce.png
[84f30643d0c64e01a9c208445419ea96.png]: https://img-blog.csdnimg.cn/84f30643d0c64e01a9c208445419ea96.png
[97196c61949842978a19e85ac55afdd2.png]: https://img-blog.csdnimg.cn/97196c61949842978a19e85ac55afdd2.png
[ece44cfcd9b746e792ada64b5c74514a.png]: https://img-blog.csdnimg.cn/ece44cfcd9b746e792ada64b5c74514a.png
[773d58c63b4f42f2ac9a5c5753a656be.png]: https://img-blog.csdnimg.cn/773d58c63b4f42f2ac9a5c5753a656be.png
[2200b185d1c445f881d50e6836f7e814.png]: https://img-blog.csdnimg.cn/2200b185d1c445f881d50e6836f7e814.png
[1b5a4c51203143ab93415bee34ffc41c.png]: https://img-blog.csdnimg.cn/1b5a4c51203143ab93415bee34ffc41c.png
[7a286ca543ac42f7b93589fc98f6b51b.png]: https://img-blog.csdnimg.cn/7a286ca543ac42f7b93589fc98f6b51b.png
[5576a02438d0478fa683d4be833211ed.png]: https://img-blog.csdnimg.cn/5576a02438d0478fa683d4be833211ed.png
[7cf62d4a70594bf783e9f84f6a438371.png]: https://img-blog.csdnimg.cn/7cf62d4a70594bf783e9f84f6a438371.png
[3b75da5afcb84324912c7f7af7c17228.png]: https://img-blog.csdnimg.cn/3b75da5afcb84324912c7f7af7c17228.png
[e8baf983f6c94ff3a53b4ded73cb4e42.png]: https://img-blog.csdnimg.cn/e8baf983f6c94ff3a53b4ded73cb4e42.png
[67dfbd4777ea4833b3ae75fcd221c5e9.png]: https://img-blog.csdnimg.cn/67dfbd4777ea4833b3ae75fcd221c5e9.png
[065ca914384e415e9a53aaac066cf997.png]: https://img-blog.csdnimg.cn/065ca914384e415e9a53aaac066cf997.png
[4bf168c0ee1a4782b227d45a68180e82.png]: https://img-blog.csdnimg.cn/4bf168c0ee1a4782b227d45a68180e82.png