Java -- 了解多线程

野性酷女 2021-11-02 05:01 278阅读 0赞

## 一，线程的概念 ##

1.  进程  
    进程是程序的一次动态执行过程，他对应了从代码加载，执行到执行完毕的一个完整过程，这个过程也是进行本身从产生，发展至消亡的过程，操作系统同时管理一个计算机系统中的多个进程，让计算机系统中的多个进程轮流使用CPU资源，或者共享操作系统的其他资源；  
    **进程的特点：**  
    （1）进程是系统运行程序的基本单元；  
    （2）每一个进程都有自己独立的一块内存空间，一组系统资源；  
    （3）每一个进程的内部数据和状态都是完全独立的；
2.  线程  
    线程是进程中执行运算的最小单位,可完成一个独立的顺序控制流程。每个进程中,必须至少  
    建立一个线程(这个线程称为主线程)来作为这个程序运行的入口点。如果在一个进程中同时运行  
    了多个线程,用来完成不同的工作,则称之为“多线程。
3.  多线程的好处  
    多线程作为一种多任务并发的工作方式.有着广泛的应用.合理地使用线程,将减少开发和维  
    护的成本,甚至可以改善复杂应用程序的性能。使用多线程的优势如下；  
    （1）充分利用CPU的资源:执行单线程程序时,若程序发生阻塞,CPU可能会处于空闲状态  
    这将造成计算机资源浪费,而使用多线程可以在某个线程处理休眠或阻塞状态时运行其他  
    线程,这样.大大提高了资源利用率；  
    （2）简化编程模型:一个既长又复杂的进程可以考虑分为多个线程,成为几个独立的运行部分,  
    如使用时、分、秒来描述当前时间,如果写成单线程程序可能需要多重循环判断,而如果  
    使用多线程,时、分、秒各使用一个线程控制,每个线程仅需实现简单的流程,简化了程  
    序逻辑,这样更有助于开发人员对程序的理解和维护；  
    （3）带来良好的用户体验:由于多个线程可以交替执行,减少或避免了因程序阻塞或意外情况  
    造成的响应过慢现象,降低了用户等待的机率；

## 二，在Java中实现多线程 ##

1.  Thread类及其常用方法

<table> 
 <thead> 
  <tr> 
   <th>构造方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Thread</td> 
   <td>分配新的Thread对象</td> 
  </tr> 
  <tr> 
   <td>Thread(Runnable target)</td> 
   <td>分配新的Thread对象，target为run（）方法被调用的对象</td> 
  </tr> 
  <tr> 
   <td>Thread(Runnable target,String name)</td> 
   <td>分配新的Thread对象，target为run（）方法被调用的对象，name为新线程的名称</td> 
  </tr> 
  <tr> 
   <td>void run()</td> 
   <td>执行任务操作的方法</td> 
  </tr> 
  <tr> 
   <td>void start()</td> 
   <td>使该线程开始执行，java虚拟机调用该线程的run（）方法</td> 
  </tr> 
  <tr> 
   <td>void sleep(long millis)</td> 
   <td>在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）</td> 
  </tr> 
  <tr> 
   <td>String getName()</td> 
   <td>返回线程的名称</td> 
  </tr> 
  <tr> 
   <td>int getPriority()</td> 
   <td>返回线程的优先级</td> 
  </tr> 
  <tr> 
   <td>void setPriority(int newPriority)</td> 
   <td>更改线程的优先级</td> 
  </tr> 
  <tr> 
   <td>static ThreadcurrentThread()</td> 
   <td>返回当前正在执行的线程对象的引用</td> 
  </tr> 
  <tr> 
   <td>boolean isAlive()</td> 
   <td>测试线程是否处于活动状态</td> 
  </tr> 
  <tr> 
   <td>void join()</td> 
   <td>等待该线程终止</td> 
  </tr> 
  <tr> 
   <td>void interrupt()</td> 
   <td>中断线程</td> 
  </tr> 
  <tr> 
   <td>void yield()</td> 
   <td>暂停当前正在执行的线程对象，并执行其他线程</td> 
  </tr> 
 </tbody> 
</table>

1.  主线程  
    在Java程序启动时,一个线程立刻运行,该线程通常称为程序的主线程。Java程序中的 public static void main()方法是主线程的入口,每个进程都至少有一个主线程。它是程序开始时就执行的。  
    主线程的重要性体现在以下两个方面。

> （1）它是产生其他子线程的线程。  
> （2）通常它必须最后完成执行,因为它执行各种关闭动作。

public class DemoApplication {
        public static void main(String[] args) {
            Thread t= Thread.currentThread();
            System.out.println("当前线程是:"+t.getName());
            t.setName("MyJavaThread");
            System.out.println("当前线程名是:"+t.getName());
        }
    }

![在这里插入图片描述][20190810104406952.png]  
使用一个线程的步骤可以分为四个步骤

> 1.定义一个线程；  
> 2.创建线程对象；  
> 3.启动线程；  
> 4.终止线程；

1.  继承Thread类创建线程  
    因为使用此方法创建线程类,此线程类需要继承 Thread Thread类的run()方法。因为Thread类的run()方法是线程要执行操作任务的方法,所以线程要执行的操作代码都需要写在run()方法中,并通过调用 start()方法启动线程后调用。  
    **主要步骤：**

> 1定义 My Thread Thread类。  
> 2重写run()方法,在run()方法中实现数据输出  
> 3创建线程对象,调用 start()方法启动线程。

public class MyThread extends Thread {
        //重写run方法
        public void run() {
            for (int i=1;i<100;i++){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
    //测试类
    public class Test{
        public static void main(String[] args) {
            MyThread myThread= new MyThread();
            myThread.start();//启动线程
        }
    }

1.  实现Runnable接口创建线程  
    Runnable 接口定义在java.lang包中，其中声明了一个抽象方法run(),即 public void run()，一个类可以通过实现 Runnable接口并实现其run()方法完成线程的所有活动,已实现的run()方法称为该线程对象的线程体。任何实现 Runnable接口的对象都可以作为一个线程的目标对象。  
    **主要步骤：**

> 1.定义 MyRunnable类实现Runnable接口，并实现 Runnable接口的run()方法,在run()方法中实现输出数据。  
> 2.创建 MyRunnable myRunnable。  
> 3.创建一个Thread类的对象 myThread,将 myRunnable对象作为 Thread类构造方法的参数传入。  
> 4.调用 myThread 对象的start()方法启动线程。

public class MyRunnable implements Runnable {
        //实现run方法
        public void run() {
            for (int i=1;i<100;i++){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
    //测试类
    public class Test{
        public static void main(String[] args) {
            MyRunnable myRunnable = new MyRunnable();
            Thread myThread = new Thread(myRunnable);
            myThread.start();
        }
    }

**两种实现线程方法总结：**  
两种创建线程的方式有各自的特点和应用领域:  
直接继承 Thread类的方式编写简单,可以直接操作线程,适用于单继承的情况:当一个线程继承了另一个类时,就只能用实现 Runnable接口的方式来创建线程,而且这种方式还可以实现多个线程之间资源的共享。

**附加知识：**  
线程实例调用start()方法和直接调用run()方法的区别：（start()启动线程，run()调用实例方法）

start()方法：

//测试类
    public class Test{
        public static void main(String[] args) {
            MyThread myThread= new MyThread();
            MyThread myThread2= new MyThread();
            myThread.start();
            myThread2.start();
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM4Mjg0NA_size_16_color_FFFFFF_t_70]  
注：由于一个CPU在一个时间点只能执行一个线程，因此多个线程是交替执行的；

run()方法：

//测试类
    public class Test{
        public static void main(String[] args) {
            MyThread myThread= new MyThread();
            MyThread myThread2= new MyThread();
            myThread.run();
            myThread2.run();
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM4Mjg0NA_size_16_color_FFFFFF_t_70 1][]  
注：线程名变为“main”，直接调用run()后，不存在子线程的启动，因此只有主线程执行，只有一条路径，也就不存在多线程的并行交替执行了，t1调用了run()方法之后，返回main()方法，t2再调用run()方法；第一次run()方法执行完毕之后才会执行第二次的run()方法;

## 三，线程的状态 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM4Mjg0NA_size_16_color_FFFFFF_t_70 2]  
**1. 创建状态**  
在程序中用构造方法创建了一个线程对象后，新的线程对象就处于创建状态，此时，它已经获取了相应的资源，但还没有处于可运行状态，这时可以通过 Thread类的方法来设置线程对象的属性，如设置线程名（setN()），设置线程优先级（setPriority()）等。

**2. 就绪状态**  
线程创建之后,就可以通过调用 start()法启动线程，即进入就绪状态。此时，线程将进入线程队列排队，等待CPU资源，这表明它已经具备了运行条件，在未获得CPU资源时，仍不能真正执行。

**3. 运行状态**  
当就绪状态的线程获得CPU资源时，即可转入运行状态，执行run()方法。对只有一个CPU的计算机而言，任何时刻只能有一个处于运行状态的线程占用CPU，即获得CPU资源。

**4. 阻塞状态**  
一个正在运行的线程因某种原因不能继续运行时，进入阻塞状态。阻塞状态是一种“不可运行  
的状态，而处于这种状态的线程在得到一个特定的事件之后会转回可运行状态。

可能使线程暂停执行的条件如下：

> 1.由于线程优先级比较低,因此它不能获得CPU资源。  
> 2.使用sleep()方法使线程休眠。  
> 3.通过调用wait()方法,使线程等待。  
> 4.通过调用 yield()方法,线程显式出让CPU控制权。  
> 5.线程由于等待一个文件,I/O事件被阻塞。

**5. 死亡状态**  
一个线程的run方法运行完毕，线程则进入死亡状态。处于死亡状态的线程不具有继续运行的能力。

代码示例：

public class MyThread implements Runnable {
        public void run() {
            try{
                System.out.println("线程thread在运行状态");
                Thread.sleep(500);
                System.out.println("线程thread在500毫秒休眠后重新运行");
            }catch (InterruptedException IE){
                System.out.println("线程中断状态");
            }
        }
        public static void main(String[] args) {
            Thread thread = new Thread(new MyThread());
            System.out.println("线程thread为新建状态");
            thread.start();
            System.out.println("线程thread为就绪状态");
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM4Mjg0NA_size_16_color_FFFFFF_t_70 3]

## 四，线程的调度 ##

**1. 线程的优先级**  
当同一时刻有一个或多个线程处于运行状态时，它们需要排队等待CPU资源，每个线程会自动获得一个线程的优先级，优先级的高低反映线程的重要或紧急程度。那么此刻，一般情况下优先级高的线程获得CPU资源的概率较大,但这个结果不是绝对的。  
线程的优先级用1~10（整数）表示，1表示优先级最低，10表示优先级最高，默认值是5。

public class MyThread implements Runnable {
        public void run() {
            for (int i=0;i<100;i++){
                System.out.println(Thread.currentThread().getName()+"正在运行："+i);
            }
        }
        public static void main(String[] args) {
    //        通过构造方法指定线程名称
            Thread thread1 = new Thread(new MyThread(),"线程A");
            Thread thread2 = new Thread(new MyThread(),"线程B");
    //        设置线程的优先级
            thread1.setPriority(Thread.MAX_PRIORITY);//优先级为10，或者thread.setPriority(10)；
            thread2.setPriority(Thread.MIN_PRIORITY);//优先级为1，或者thread.setPriority(1)；
    //        设置线程的优先级
            System.out.println("线程A的优先级："+thread1.getPriority());
            System.out.println("线程B的优先级："+thread2.getPriority());
            thread1.start();
            thread2.start();
        }
    }

**2. 线程的休眠**  
在程序中允许一个线程进行暂时休眠，直接使用Thread.sleep()方法即可以实现线程的休眠。  
语法如下：  
public static void sleep(long millis);

sleep方法会让当前线程休眠（停止执行）millis毫秒，线程由运行中的状态进入不可运行状态，睡眠时间过后线程会再次进入可运行状态。调用sleep方法需处理InterruptedException异常。

public class DemoApplication {
        public static void main(String[] args) {
            System.out.println("等待");
            Wait.bySec(new Long(5));//让主线程等待五秒后再执行
            System.out.println("start");
        }
    }
    public class Wait {
        public static void bySec(Long s) {
            for (int i=0;i<s;i++){
                System.out.println(i+1+"秒");
                try{
                    Thread.sleep(1000);
                }catch (InterruptedException IE){
                    IE.printStackTrace();
                }
            }
        }
    }

**3. 线程的强制运行**  
join()方法使当前线程暂停执行，等待调用该方法的线程结束后再继续执行本线程。  
它有三个重载方法，语法如下:  
public final void join()  
public final void join(long mills)  
public final void join(long mills, int nanos)

与 sleep()方法一样，调用join()方法需要处理 Interruptedexception异常。

public class MyThread implements Runnable{
        @Override
        public void run() {
            for (int i=0;i<10;i++){
                try{
                    Thread.sleep(1000);//增加线程假体执行的几率
                }catch (InterruptedException IE){
                    IE.printStackTrace();
                }
    //            输出当前线程的信息
                System.out.println(Thread.currentThread().getName()+"运行："+i);
            }
        }
    }
    
    //测试类
    public class DemoApplication {
        public static void main(String[] args) {
            System.out.println("=============线程强制执行========");
            Thread thread = new Thread(new MyThread());
            thread.start();
            for (int i=0;i<20;i++){
                if(i==5){
                    try{
                        thread.join();
                    }catch (InterruptedException IE){
                        IE.printStackTrace();
                    }
                }
                try{
                    Thread.sleep(1000);
                }catch (InterruptedException IE){
                    IE.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"运行："+i);
            }
    
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM4Mjg0NA_size_16_color_FFFFFF_t_70 4]  
当主线程运行到i值为5的时候，子线程调用join()方法后，阻塞主线程，知道子线程运行完毕后，主线程才能继续执行。

**4. 线程的礼让**  
语法如下：  
public static void yield();

yield()方法可暂停当前线程执行，允许其他具有相同优先级的线程获得运行机会，该线程仍处于就绪状态，不转为阻塞状态，此时，系统选择其他相同或更高优先级线程执行，若无其他相同或更高优先级线程,则该线程继续执行。

public class MyThread implements Runnable{
        @Override
        public void run() {
            for (int i=0;i<5;i++){
                System.out.println(Thread.currentThread().getName()+"运行："+i);
                if (i==3){
                    System.out.print("线程礼让：");
                    Thread.yield();
                }
            }
        }
    }
    //测试类
    public class DemoApplication {
        public static void main(String[] args) {
            MyThread myThread= new MyThread();
            Thread t1= new Thread(myThread,"线程A");
            Thread t2= new Thread(myThread,"线程B");
            t1.start();
            t2.start();
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM4Mjg0NA_size_16_color_FFFFFF_t_70 5]  
当线程满足条件（i==3）时，建议当前线程暂停，让其他线程先执行。当然，这仅是提供一种可能。

## 五，线程的同步 ##

**1. 线程同步的实现**

1.  同步方法  
    使用 synchronized修饰的方法控制对类成员变量的访问。每个类实例对应一把锁，方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行状态。这种机制确保了同一时刻对应一个实例，从而有效避免了类成员变量的访问冲突。  
    通俗地说一个大房子里有很多房间，其中有一个房间只允许一人进入，就需要给这个房间上锁，房间只有一把钥匙，且放在指定的位置，拿到钥匙的人可以进入房间，按照自己的计划使用房间后，离开房间并把钥匙放回原处，这样第二个人才能拿到钥匙进入房间。

通过在方法声明中加入 synchronized关键字来声明同步方法。其语法如下：

> 访问修饰符 synchronized 返回类型 方法名(参数列表)(//省略方法体…)

或者

> synchronized 访问修饰符 返回类型 方法名(参数列表)(//省略方法体…)

public class MyThread implements Runnable{
    
        private int count=10;   //记录剩余票数
        private int num=0;  //记录买到第几张票
        private boolean flag=false; //记录是否卖完
    
        @Override
        public void run() {
            while(!flag){
                sale();
            }
        }
    //    同步方法：售票
        public synchronized void sale(){
            if (count<=0){
                flag=true;
                return;
            }
            //第一步：修改数据
            num++;
            count--;
            try{
                Thread.sleep(1000); //模拟网络延迟
            }catch (InterruptedException IE){
                IE.printStackTrace();
            }
            //第二步：显示信息
            System.out.println(Thread.currentThread().getName()+"抢到第"+num+"张票，剩余"+count+"张票");
        }
    }
    
    //测试类
    public class DemoApplication {
        public static void main(String[] args) {
            MyThread myThread= new MyThread();
            Thread person1 = new Thread(myThread,"张三");
            Thread person2 = new Thread(myThread,"李四");
            Thread person3 = new Thread(myThread,"王晓明");
            person1.start();
            person2.start();
            person3.start();
        }
    }

同步方法的缺陷:  
如果将一个运行时间比较长的方法声明成 synchronized将会影响效率。例如,将线程中的run()方法声明成 synchronized，由于在线程的整个生命周期内它一直在运行，因此这样就有可能导致run()方法会执行很长时间，那么其他的线程就需要一直等到run()方法结束了才能执行。

1.  同步代码块  
    代码块即使用\{\}括起来的一段代码，使用synchronized关键字修饰的代码块称为同步代码块。  
    其语法如下:  
    synchronized(syncobject)\{  
    //需要同步的代码  
    \}

**2. 线程安全的类型**  
此处省略；

[20190810104406952.png]: /images/20211102/08bdbba93bd0478b99a69b27cf9827e2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM4Mjg0NA_size_16_color_FFFFFF_t_70]: /images/20211102/9523fe4e6e18487ba4535f26f722afc5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM4Mjg0NA_size_16_color_FFFFFF_t_70 1]: /images/20211102/18ef9c9e7ab8487c851ecb7036803af6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM4Mjg0NA_size_16_color_FFFFFF_t_70 2]: /images/20211102/8f4adea8d3874a16b8d5085ea9325ba4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM4Mjg0NA_size_16_color_FFFFFF_t_70 3]: /images/20211102/36df974643bc450c8666afea404710bc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM4Mjg0NA_size_16_color_FFFFFF_t_70 4]: /images/20211102/598f00f3a21f453e978ecd74b73215a4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM4Mjg0NA_size_16_color_FFFFFF_t_70 5]: /images/20211102/a08175ed42e9424fa400eb19a49ea109.png