【Java基础】线程

向右看齐 2024-03-26 11:49 7阅读 0赞

## 线程 ##

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

进程：运行的程序  
线程：是由进程创建的

*  是进程的一个实体
 *  一个进程可以有多个线程

> 线程与进程相似，但线程是一个比进程更小的执行单位。一个进程在其执行的过程中可以产生多个线程。与进程不同的是同类的多个线程共享进程的**堆**和**方法区**资源，但每个线程有自己的**程序计数器**、**虚拟机栈**和**本地方法栈**

**分类**

*  单线程：同一时刻，执行一个线程
 *  多线程：同一时刻，执行多个线程

**并发与并行**

*  并发: 同一时刻，多个任务交替执行，给人一种同时执行的错觉；eg单核cpu执行多任务
 *  并行：同一时刻，多个任务同时执行；eg多核cpu可以实现并行  
    ![在这里插入图片描述][8373a77da6f7434983dbab64bd87e780.png]

用代码获取cpu核心数

Runtime runtime=Runtime.getRuntime();
    
            //获取当前电脑的cup核心数
    
            int cupNums= runtime.availableProcessors();
    
            System.out.println(cupNums);//8

### 使用 ###

创建线程有两种方式  
![在这里插入图片描述][6897016f34d94fabbf32b30c905dc191.png]

#### 继承Thread类 ####

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

package com.Thread_;
    
    public class Thread01 {
        
    
        public static void main(String[] args) {
        
    
            DownLoad downLoad = new DownLoad();
            
    
            downLoad.start();//开启另一个线程
    
            //不能直接调用run,否则还是在主线程中
    
            /**
    
             * start()实际调用的是 private native void start0();
    
             * 由JVM来调用，把Thread-0变成可运行状态，并不一定立刻执行，由cpu决定
             * 调用 `start()` 方法方可启动线程并使线程进入就绪状态，直接执行 `run()` 方法的话不会以多线程的方式执行。**
    
             */
    
            //主线程不会阻塞
    
            int percetnt=0;
    
            while (percetnt<=100){
        
    
                System.out.println("等待添加文件...("+Thread.currentThread().getName()+")");
    
                percetnt+=1;
    
                try {
        
    
                    Thread.sleep(1000);
    
                } catch (InterruptedException e) {
        
    
                    e.printStackTrace();
    
                }
    
            }
    
        }
    
    }
    
    class DownLoad extends Thread{
        
    
        //继承Thread类，重写run方法
    
        @Override
    
        public void run() {
        
    
            int percetnt=0;
    
            while (percetnt<=100){
        
    
                //Thread.currentThread().getName() 获取线程的名字 Thread-0
    
                System.out.println("文件1已下载"+percetnt+"%("+Thread.currentThread().getName()+")");
    
                percetnt+=1;
    
                try {
        
    
                    Thread.sleep(1000);
    
                } catch (InterruptedException e) {
        
    
                    e.printStackTrace();
    
                }
    
            }
    
        }
    
    }

在开启线程的同时可以在终端输入 `jconsole`查看线程

> jconsole,如果遇到 “无法安全连接的问题”，  
> 可以在idea的VM option中添加如下参数
> 
>     -Dcom.sun.management.jmxremote
>     -Dcom.sun.management.jmxremote.port=8011
>     -Dcom.sun.management.jmxremote.ssl=false
>     -Dcom.sun.management.jmxremote.authenticate=false

#### 实现Runnable接口 ####

##### 模拟代理模式 #####

start()最终调用了run()

//Thread 的代理模式的简单介绍
    
    class Thread2 implements Runnable {
        
    
        private Runnable target=null;
    
        //1.Thread 的构造器传入一个实现了 Runnable的类的实例
    
        public Thread2(Runnable target) {
        
    
            //2.将实例传给自己的属性
    
            this.target = target;
    
        }
    
        @Override
    
        public void run() {
        
    
            if(target!=null){
        
    
                //6.调用传入实例的run（）
    
                target.run();
    
            }
    
        }
    
        //3.调用start方法
    
        public void start(){
        
    
            //4.调用start01()方法
    
            start01();
    
        }
    
        private void start01(){
        
    
            //5.调用成员方法run()
    
            run();
    
        }
    
    }

实例

package com.Thread_;
    
    public class Thread02 {
        
    
        public static void main(String[] args) {
        
    
            DownLoad downLoad2 = new DownLoad();
    
    //        downLoad.start();这里不能直接使用start
    
            /**
    
             * 这里底层使用了设计模式：代理模式
    
             */
    
            Thread thread = new Thread(downLoad2);
    
            thread.start();
    
            //主线程不会阻塞
    
            int percetnt = 0;
    
            while (percetnt <= 100) {
        
    
                System.out.println("等待添加文件...(" + Thread.currentThread().getName() + ")");
    
                percetnt += 1;
    
                try {
        
    
                    Thread.sleep(1000);
    
                } catch (InterruptedException e) {
        
    
                    e.printStackTrace();
    
                }
    
            }
    
        }
    
    }
    
    class DownLoad2 implements Runnable{
        
    
        //继承Thread类，重写run方法
    
        @Override
    
        public void run() {
        
    
            int percetnt=0;
    
            while (percetnt<=100){
        
    
                //Thread.currentThread().getName() 获取线程的名字 Thread-0
    
                System.out.println("文件1已下载"+percetnt+"%("+Thread.currentThread().getName()+")");
    
                percetnt+=1;
    
                try {
        
    
                    Thread.sleep(1000);
    
                } catch (InterruptedException e) {
        
    
                    e.printStackTrace();
    
                }
    
            }
    
        }
    
    }

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

### 中断 ###

package com.Thread_;
    
    public class Thread03 {
        
    
        public static void main(String[] args) {
        
    
            DownLoad3 downLoad3 = new DownLoad3();
    
            downLoad3.start();
    
            try {
        
    
                Thread.sleep(15);
    
            } catch (InterruptedException e) {
        
    
                e.printStackTrace();
    
            }
    
            downLoad3.setLoop(false);
    
        }
    
    }
    
    class DownLoad3 extends Thread {
        
    
        private int percent=0;
    
        private boolean loop=true;
    
        public void setLoop(boolean loop) {
        
    
            this.loop = loop;
    
        }
    
        @Override
    
        public void run() {
        
    
            while(loop)
    
            {
        
    
                try {
        
    
                    Thread.sleep(5);
    
                } catch (InterruptedException e) {
        
    
                    e.printStackTrace();
    
                }
    
                System.out.println("文件1已下载" + percent + "%(" + Thread.currentThread().getName() + ")");
    
                percent++;
    
            }
    
        }
    
    }

### 方法 ###

#### 常用方法一 ####

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

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

##### 优先级 #####

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

> 优先级越高，被执行的概率越高

package com.Thread_;
    
    public class Thread04 {
        
    
        public static void main(String[] args) {
        
    
            DownLoad4 downLoad4 = new DownLoad4();
    
            //给线程命名
    
            downLoad4.setName("线程01");
    
            //设置优先级
    
            downLoad4.setPriority(Thread.MIN_PRIORITY);
    
            downLoad4.start();
    
            //获取当前线程的名称
    
            System.out.println(Thread.currentThread().getName());
    
            for (int i = 0; i < 5; i++) {
        
    
                System.out.println("haha");
    
            }
    
            downLoad4.interrupt();//中断线程的休眠,但并不是真正中断线程，而是唤醒线程，让其继续工作
    
            try {
        
    
                //当前线程休眠
    
                Thread.sleep(1000);
    
            } catch (InterruptedException e) {
        
    
                e.printStackTrace();
    
            }
    
        }
    
    }
    
    class DownLoad4 extends Thread{
        
    
        //继承Thread类，重写run方法
    
        @Override
    
        public void run() {
        
    
            while (true){
        
    
                //Thread.currentThread().getName() 获取线程的名字 Thread-0
    
                System.out.println("ing....");
    
                try {
        
    
                    Thread.sleep(10000);
    
                } catch (InterruptedException e) {
        
    
                    //e.printStackTrace();
    
                    System.out.println("休眠被中断");
    
                }
    
            }
    
        }
    
    }

#### 常用方法二 ####

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

package com.Thread_;
    
    public class Thread05 {
        
    
        public static void main(String[] args) throws InterruptedException {
        
    
            LaoDa laoDa = new LaoDa();
    
            laoDa.start();//会先执行完laoda的线程之后，再执行main的线程
    
            laoDa.join();
    
    //        Thread.yield();//让cpu暂且先不执行该线程，但不一定会成功
    
            for (int i = 0; i < 5; i++) {
        
    
                System.out.println("老二吃饺子");
    
            }
    
        }
    
    }
    
    class LaoDa extends Thread{
        
    
        @Override
    
        public void run() {
        
    
            for (int i = 0; i < 5; i++) {
        
    
                System.out.println("老大吃包子");
    
            }
    
        }
    
    }

#### 常用方法三 ####

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

package com.Thread_;
    
    public class Thread06 {
        
    
        public static void main(String[] args) {
        
    
            Thread thread = new Thread(new Brother());
    
            thread.setDaemon(true);//先设置成守护进程，当其他进程都结束之后，守护进程也结束
    
            thread.start();//在开始
    
            for (int i = 0; i < 10; i++) {
        
    
                try {
        
    
                    Thread.sleep(1000);
    
                } catch (InterruptedException e) {
        
    
                    e.printStackTrace();
    
                }
    
                System.out.println("哥哥在");
    
            }
    
        }
    
    }
    
    class Brother implements Runnable{
        
    
        @Override
    
        public void run() {
        //无限循环
    
            while (true){
        
    
                try {
        
    
                    Thread.sleep(1000);
    
                } catch (InterruptedException e) {
        
    
                    e.printStackTrace();
    
                }
    
                System.out.println("弟弟在");
    
            }
    
        }
    
    }

### 状态 ###

官方文档有6种状态，其中Runnable有两种状态Ready,Running  
![在这里插入图片描述][b52f036e5f0a433aa32093aff870874f.png]  
![在这里插入图片描述][faf3a4ab71534cf59d6d2d8650061d37.png]

package com.Thread_;
    
    public class Thread07 {
        
    
        public static void main(String[] args) {
        
    
            Ha ha = new Ha();
    
            System.out.println(ha.getState());//NEW
    
            ha.start();
    
            for (int i = 0; i < 5; i++) {
        
    
                try {
        
    
                    Thread.sleep(800);
    
                } catch (InterruptedException e) {
        
    
                    e.printStackTrace();
    
                }
    
                System.out.println(ha.getState());//RUNNABLE  或者TIMED_WAITING
    
            }
    
            System.out.println(ha.getState());//TERMINATED
    
        }
    
    }
    
    class Ha extends Thread{
        
    
        @Override
    
        public void run() {
        
    
            for (int i = 0; i < 5; i++) {
        
    
                try {
        
    
                    Thread.sleep(1000);//TIMED_WAITING
    
                } catch (InterruptedException e) {
        
    
                    e.printStackTrace();
    
                }
    
                System.out.println("ha");//RUNNABLE
    
            }
    
        }
    
    }

### 同步 ###

![在这里插入图片描述][d3cbe96c5ad043dcb2241f3d2fb4c5a9.png]  
![在这里插入图片描述][61f63e53d1de4837b2db9868caf579bb.png]

### 锁 ###

#### 互斥锁 ####

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

public class Station {
        
        public static void main(String[] args) {
        
            SellTaket sellTaket = new SellTaket();
            Thread thread = new Thread(sellTaket);
            Thread thread2 = new Thread(sellTaket);
            Thread thread3 = new Thread(sellTaket);
            thread.start();
            thread2.start();
            thread3.start();
        }
    }
    
    class SellTaket implements Runnable {
        
        static int count = 10;
       static private boolean loop = true;
        Object lock=new Object();
    
        /**
         * 非静态方法，所可以加到这个类本身，或者其他对象，但是要求是同一个
         */
    
        private synchronized void sell() {
        
            if (count > 0) {
        
                try {
        
                    Thread.sleep(100);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                count = count - 1;
                System.out.println("窗口 " + Thread.currentThread().getName() + "卖出了一张票,还剩余" +
                        (count) + "张票");
            } else {
        
                System.out.println("窗口 " + Thread.currentThread().getName() + "售票结束" + count);
                loop = false;
            }
        }
        //或者代码块用synchronized修饰(推荐）
        private  void sell2(){
        
            //对象锁可以是this,也可以是其他的类属性对象
            // 要求所有线程的对象锁是同一个
            synchronized(this){
        
                if(count>0){
        
                    try {
        
                        Thread.sleep(100);
    
                    } catch (InterruptedException e) {
        
    
                        e.printStackTrace();
    
                    }
    
                    count=count-1;
    
                    System.out.println("窗口 "+ Thread.currentThread().getName() +"卖出了一张票,还剩余"+
    
                            (count)+"张票");
    
                }else{
        
    
                    System.out.println("窗口 "+ Thread.currentThread().getName() +"售票结束"+count);
    
                    loop=false;
    
                }
    
            }
    
        }
        private  void sell3(){
        
            //对象锁可以是this,也可以是其他的类属性对象
            // 要求所有线程的对象锁是同一个
            synchronized(lock){
        
                if(count>0){
        
                    try {
        
                        Thread.sleep(100);
    
                    } catch (InterruptedException e) {
        
    
                        e.printStackTrace();
    
                    }
    
                    count=count-1;
    
                    System.out.println("窗口 "+ Thread.currentThread().getName() +"卖出了一张票,还剩余"+
    
                            (count)+"张票");
    
                }else{
        
    
                    System.out.println("窗口 "+ Thread.currentThread().getName() +"售票结束"+count);
    
                    loop=false;
    
                }
    
            }
    
        }
        /**
         * 静态方法，所可以加到这个类.Class
         */
    
        private static synchronized void sell4() {
        
            if (count > 0) {
        
                try {
        
                    Thread.sleep(100);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                count = count - 1;
                System.out.println("窗口 " + Thread.currentThread().getName() + "卖出了一张票,还剩余" +
                        (count) + "张票");
            } else {
        
                System.out.println("窗口 " + Thread.currentThread().getName() + "售票结束" + count);
                loop = false;
            }
        }
        //或者代码块用synchronized修饰(推荐）
        private static   void sell5(){
        
            //对象锁不饿能写this或者其他属性对象，要写类名.class
            // 要求所有线程的对象锁是同一个
            synchronized(SellTaket.class){
        
                if(count>0){
        
                    try {
        
                        Thread.sleep(100);
    
                    } catch (InterruptedException e) {
        
    
                        e.printStackTrace();
    
                    }
    
                    count=count-1;
    
                    System.out.println("窗口 "+ Thread.currentThread().getName() +"卖出了一张票,还剩余"+
    
                            (count)+"张票");
    
                }else{
        
    
                    System.out.println("窗口 "+ Thread.currentThread().getName() +"售票结束"+count);
    
                    loop=false;
    
                }
    
            }
    
        }
    
        @Override
        public void run() {
        
            while (loop) {
        
                sell();
    //            sell2();
    //            sell3();
    //            sell4();
    //            sell5();
            }
    
        }
    }

#### 死锁 ####

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

#### 释放锁 ####

![\#\#\# 释放][25174ed48a3045708142e41b8e3d1315.png]  
![在这里插入图片描述][4a472dbfe4544f999946fef0f9773ff1.png]

### 线程间的通信 ###

[参考文章][Link 1]

#### 共享内存 ####

关键字 Volatile

#### 消息传递 ####

##### wait()/notify() #####

`wait()` 通常被用于线程间交互/通信，释放了锁  
`wait()` 方法被调用后，线程不会自动苏醒，需要别的线程调用同一个对象上的 `notify()` 或者 `notifyAll()` 方法。

##### join() #####

#### 管道流 ####

管道流是是一种使用比较少的线程间通信方式，管道输入/输出流和普通文件输入/输出流或者网络输出/输出流不同之处在于，它主要用于线程之间的数据传输，传输的媒介为管道。

管道输入/输出流主要包括4种具体的实现：PipedOutputStrean、PipedInputStrean、PipedReader和PipedWriter，前两种面向字节，后两种面向字符。

java的管道的输入和输出实际上使用的是一个循环缓冲数组来实现的，默认为1024，输入流从这个数组中读取数据，输出流从这个数组中写入数据，当这个缓冲数组已满的时候，输出流所在的线程就会被阻塞，当向这个缓冲数组为空时，输入流所在的线程就会被阻塞。

[8373a77da6f7434983dbab64bd87e780.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/1a2940e6c53140c5a413302231bd4e06.png
[6897016f34d94fabbf32b30c905dc191.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/1d4b3e35a21d476189db2a7154070373.png
[8e37980c92724e528da21768ddcffd8f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/be2bccaabdb94f4bb28f91c8a165092d.png
[9434c33b417842dc878bd723ab1b2373.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/b6e2fe6a2f5b42e89ad24177bec826f3.png
[a2013da62e4c4ba7babee1998caecf0d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/befcf41441ad4e45938f55871ed9d31a.png
[f19f78907f0145de8b8e9d9c1b0bf806.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/3bd55ff4e3dd45e0926b057c775c2609.png
[d25a2512b5974950a218e7986588417c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/3f8d83932e864c5087e9d4d3e90abafc.png
[0c6d2b57b5cb44df9e3777c4bbfb0874.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/3a3b11f8ddce4674a71d132cf4425596.png
[a5eda28b1dd84db885fcb91c020042b4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/13740da6eeb14b1e87f03dea7f5dcf23.png
[b52f036e5f0a433aa32093aff870874f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/76b5e6089fa146cd9f3f2d3e1e6afa18.png
[faf3a4ab71534cf59d6d2d8650061d37.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/26ce72d258e1423d822ee3ed8bcf0e90.png
[d3cbe96c5ad043dcb2241f3d2fb4c5a9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/bbe17304ec264b9695b1384ba7e6bb3e.png
[61f63e53d1de4837b2db9868caf579bb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/f00b4432b2fd4d09a47f51f286cfac69.png
[495ea34381704f82859f00e2d4c88f8e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/d53f031222ff4afeb4449e6b82a48418.png
[4aee99388a814660a64b73a0be8a2c84.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/c87f36a34d324aa2879e46ec48d0625c.png
[25174ed48a3045708142e41b8e3d1315.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/76ff9a0c91af4b0bb72a3549f5360bbd.png
[4a472dbfe4544f999946fef0f9773ff1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/0d9e47998b164044bdab18adfeccd996.png
[Link 1]: https://blog.csdn.net/weixin_46217160/article/details/108743389