【多线程】Java 多线程技能

待我称王封你为后i 2023-07-18 03:22 41阅读 0赞

## 概念 ##

区分线程和进程

进程——>.exe程序，进程是受系统操作管理的基本单元

线程：可以理解成是在进程中独立运行的子任务。

使用多线程的优点：可以最大限度地利用CPU的空闲时间来处理其他任务

使用多线程也就是在使用异步。

## 使用多线程 ##

实现方式

### 1.**继承Thread类** ###

public class MyThread extends Thread{
    
        @Override
        public void run() {
            System.out.println("run方法的打印："+Thread.currentThread().getName());
        }
    
        public static void main(String[] args) {
            for (int i = 0; i < 3; i++) {
                MyThread myThread = new MyThread();
    
                myThread.start();
            }
        }
    }

MyThread类中的run 方法比较晚，这就是说明使用多线程技术时，代码的运行结果与代码执行顺序或调用顺序无关

线程是一个子任务，CPU以不确定的方式，或者说是以随机的时间来调用线程中的run方法.

**a.myThread.start(),方法是通知“线程规划器”此线程已经准备就绪，等待调用线程对象的run()方法。**

**b.myThread.run()就不是异步执行了，而是同步，那么此此线程对象并不是交给“线程规划器”处理，而是由main主线程来调用run()方法，也就是必须等run()方法中的代码执行后才可以执行后面的代码。**

### **2.实现Runnable接口** ###

public class MyRunnable implements Runnable {
        @Override
        public void run() {
            System.out.println("运行中！");
        }
    
    
        public static void main(String[] args) {
            MyRunnable myRunnable = new MyRunnable();
            Thread thread = new Thread(myRunnable);
            thread.start();
            System.out.println("运行结束！");
        }
    }

其中Thread类实现了Runnable接口，Java语言的特点就是单继承，所以为了支持多继承，完全可以实现Runnable接口的方法

Thead.java类也实现了Runnalbe接口

那也就意味着构造函数Thead(Runnable targer) 不光可以传入Runnable接口的对象，还可以传入一个Thread 类的对象，这样做完全可以将一个Thread对象中的run方法交由其他线程调用

### 3.isAlive() ###

方法是判断当前的线程是否处于活动状态

什么是活动状态，就是线程已经启动且尚未终止。线程处于正在运行或者准备开始运行的状态，就认为线程是“存活”的。

### 4.sleep() ###

方法sleep()的作用就是在指定的毫秒数内让当前“正在执行的线程”休眠（暂停这个线程）。

这个正在执行的线程是指this.currentThread()返回的线程。

Thread.sleep(2000);

### 5.停止线程 ###

在Java 中有三种方法可以终止正在运行的线程

*  1.使用推出标致，是线程正常退出，也就是当run方法完成后线程终止。
 *  2.使用stop方法强行终止线程，但是不推荐这个方法，因为stop和suspend及resume一样，都是作废的方法，使用他们可能产生不可预料的结果。
 *  3.使用interrupt

1.this.interrupted();测试**当前线程**是否已经是中断状态，执行后具有将状态标志置清除为false的功能。

2.this.isInterrupted():测试线程**Thread对象**是否已经是中断状态，但不清除标志。

**能停止的线程——异常法**

public class ExceptionThread extends Thread {
        @Override
        public void run() {
            super.run();
            try {
                for (int i = 0; i < 5000000; i++) {
                    if (this.interrupted()) {
                        System.out.println("已经是停止状态了！我要退出了！");
                        throw new InterruptedException();
                    }
                    System.out.println("i=" + (i + 1));
                }
                System.out.println("我再for下面！");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
    
        }
    
    
    }

public class Run {
        public static void main(String[] args) {
            ExceptionThread exceptionThread = new ExceptionThread();
            exceptionThread.start();
    
            try {
                Thread.sleep(1000);
                exceptionThread.interrupt();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

运行结果如下

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3MzA2MDQx_size_16_color_FFFFFF_t_70][]

**在沉睡中停止**

**a.先睡后停止**

public class SleepThread extends Thread {
        @Override
        public void run() {
            super.run();
    
            System.out.println("run begin");
    
            try {
                Thread.sleep(2000);
                System.out.println("run end");
            } catch (InterruptedException e) {
                System.out.println("在沉睡中被停止！进入catch"+this.isInterrupted());
                e.printStackTrace();
            }
    
        }
    }

public class SleepRun {
        public static void main(String[] args) {
            SleepThread sleepThread = new SleepThread();
            sleepThread.start();
            try {
                Thread.sleep(200);
                sleepThread.interrupt();
            } catch (InterruptedException e) {
                System.out.println("main catch");
                e.printStackTrace();
            }
            System.out.println("end!");
    
    
        }
    }

**运行结果**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3MzA2MDQx_size_16_color_FFFFFF_t_70 1][]

**b.先停止后睡**

public class LastSleepThread extends Thread {
        @Override
        public void run() {
            super.run();
            try {
                for (int i = 0; i < 10000; i++) {
                    System.out.println("i=" + (i + 1));
                }
                System.out.println("run begin");
                Thread.sleep(200000);
                System.out.println("run end");
            } catch (InterruptedException e) {
                System.out.println("先停止，在遇到了sleep! 进入catch!");
                e.printStackTrace();
            }
        }
    }

public class LastSleepRun {
        public static void main(String[] args) {
            try {
                LastSleepThread lastSleepThread = new LastSleepThread();
                lastSleepThread.start();
                lastSleepThread.interrupt();
                System.out.println("end");
    
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

能停止的线程——暴力停止

**使用stop（）方法停止线程**

stop()已经作废，因为如果强制让线程停止则有可能使一些请理性的工作得不到完成。另外一个情况就是对锁定的对象进行了“解锁”，导致数据得不到同步的处理，出现数据不一致的问题。

**使用return停止线程**

public class ReturnThread extends Thread {
    
        @Override
        public void run() {
            while (true){
                if(this.isInterrupted()){
                    System.out.println("停止了！");
                    return;
                }
                System.out.println("timer="+System.currentTimeMillis());
            }
    
        }
    }

public class ReturnRun {
    
        public static void main(String[] args) {
            try {
                ReturnThread returnThread = new ReturnThread();
                returnThread.start();
                Thread.sleep(2000);
                returnThread.interrupt();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3MzA2MDQx_size_16_color_FFFFFF_t_70 2][]

### 6.暂停线程 ###

暂停线程意味着此线程还可以恢复运行。在java中使用suspend()方法暂停线程，使用resume(）方法恢复线程的执行。

suspend与resume方法的缺点——独占，极易造成公共的同步对象的独占，使得其他线程无法访问公共同步对象。

### 7.yield方法 ###

yield（）方法的作用是放弃当前的CPU资源，将它让给其他的任务去占用CPU执行时间。当放弃的时间不确定，有可能刚刚放弃，马上又获得CPU时间片。

### 8.线程的优先级 ###

使用线程的优先级使用setPriority()方法。

在Java中，线程的优先级分为1-10这10个等级。

线程优先级的继承特性。

线程的优先级具有继承性，比如A线程启动B线程，则B线程的优先级与A是一样的。

优先级具有随机性。

### 9.守护线程 ###

java线程分为两种线程，一种是用户线程，另外一种是守护线程。

什么是守护线程？守护线程是一种特殊的线程，他的特性有陪伴的意义，当进程中不存在非守护线程了，则守护线程自动销毁。

典型的守护线程就是垃圾回收线程。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3MzA2MDQx_size_16_color_FFFFFF_t_70]: /images/20230528/2ca2cb952d084f33af058bc511db5d54.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3MzA2MDQx_size_16_color_FFFFFF_t_70 1]: /images/20230528/a8aa74c025fd4f7ebdd201e1ad5f1e1c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3MzA2MDQx_size_16_color_FFFFFF_t_70 2]: /images/20230528/f69570f7b8fc44308ba574a5ac839d3d.png