Java多线程机制（一）

谁借莪１个温暖的怀抱￠ 2023-10-12 08:08 8阅读 0赞

### 文章目录 ###

*  Java多线程机制
 *   *   *  一、线程的基本概念
         *  二、线程的创建和启动
         *  三、线程状态转换
         *  四、线程控制的基本方法
         *  五、线程的优先级

# Java多线程机制 #

### 一、线程的基本概念 ###

1.  概念： 线程是一个程序内部的顺序控制流
2.  线程和进程区别：  
    （1）每个进程都有独立的代码和数据空间，进程间的切换会有较大的开销。  
    （2）线程可以看成是轻量级的进程，同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器（PC），线程切换开销小。  
    （3）多进程：在操作系统中能同时运行多个程序。  
    （4）多线程：在同一个应用程序中有多个顺序流同时执行。  
    （5）通俗的说，线程是一个进程里面不同的执行路径，一个进程里面有一个主线程就是main（）方法。进程是一个静态的概念，在我们计算机内部实际运行的都是线程。
3.  Java的线程是通过java.lang.Thread类来实现的。虚拟机启动时会有一个由主方法，也就是main方法所以定义的线程。可以通过创建Thread的实例来创建新的线程。每个线程都是通过某个特定Thread对象所对应的方法run（）来完成其操作的，方法run（）称为线程体。通过调用Thread类的start()方法来启动一个线程。
4.  三个原则：  
    （1）什么是进程？进程是一个静态的概念。  
    （2）什么事线程？一个进程里面有一个主线程main（）方法，是一个程序里面、一个进程里面的不同的执行路径。  
    （3）在同一个时间点上，一个CPU只能支持一个线程在执行，如果机器是双CPU或者是双核，则支持多线程。

### 二、线程的创建和启动 ###

两种方式创建和启动新的线程，无论使用哪种方式创建线程，线程的启动都必须调用Thread类的start()方法。原则：只要能使用接口就不用从Thread类继承

1.  第一种，定义线程类实现Runnable接口

Thread myThread = new Thread(target) //target为runnable接口类型
    //Runnable中只有一个方法：
    public void run(); //用于定义线程运行体

使用Runnable接口可以为多个线程提供共享数据。在实现Runnable接口的类的run（）方法定义中可以使用Thread的静态方法`pulic static Thread currentThread() //获取当前线程的引用`

1.  第二种，可以定义一个Thread的子类并重写其run方法，示例：

class MyThread extends Thread{
    	public void ruan(){......}
    }
    //生成该类的对象
    MyThread myThread = new MyThread(...);

示例1：

package threadtest;
    
    public class TextThread1 {
        public static void main(String[] args) {
            Thread thread1 = new Thread(new Runner1());
            thread1.start();
            for (int i = 0; i < 60; i++) {
                System.out.println("Main   " + i);
            }
        }
    }
    
    //通过实现Runnable接口开启线程
    class Runner1 implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 60; i++) {
                System.out.println("Runner1   " + i);
            }
        }
    }

输出结果：  
![运行结果][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L015c2t5OTg0_size_16_color_FFFFFF_t_70]  
可以看到，main方法和run方法交替运行或者说是并行运行。  
示例2：

package threadtest;
    
    public class TextThread1 {
        public static void main(String[] args) {
           Runner1 runner1 = new Runner1();
           runner1.start();
            for (int i = 0; i < 60; i++) {
                System.out.println("Main   " + i);
            }
        }
    }
    //通过继承Thread类开启线程
    class Runner1 extends Thread {
        @Override
        public void run() {
            for (int i = 0; i < 60; i++) {
                System.out.println("Runner1   " + i);
            }
        }
    }

![输出结果][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L015c2t5OTg0_size_16_color_FFFFFF_t_70 1]  
可以看到和上面的输出方式是一样的，Main方法和run方法交替运行。

### 三、线程状态转换 ###

![线程状态转换][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L015c2t5OTg0_size_16_color_FFFFFF_t_70 2]  
1.当new一个Thread，线程就已经创建了，然后进入就绪状态，当cpu分配给线程时间片，此时该线程进入运行状态，当时间片用完线程又进入就绪状态，然后在分配时间片给线程，如此循环，最终线程终止。  
2.线程在运行过程中有可能发生意外导致线程进入阻塞状态，意外接触后，线程进入就绪状态，然后执行过程如上面地说明。

### 四、线程控制的基本方法 ###

![线程控制的基本方法][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L015c2t5OTg0_size_16_color_FFFFFF_t_70 3]

1.  sleep方法  
    属于静态方法，可以调用Thread类的静态方法`public static void sleep(long millis) throws InterruptedException` 使得当前线程休眠，也就是暂停当前线程执行millis毫秒。在哪个线程里面sleep方法就让哪个线程睡眠。由于sleep是静态方法，sleep可以由类名直接调用，Thread.sleep(…)。注意：stop方法已经弃用！

示例：仅作为示例学习，不建议直接使用interrupt结束线程

package threadtest;
    
    import java.util.Date;
    
    public class TestInterrupt {
    
        public static void main(String[] args) {
            MyThread myThread = new MyThread();
            myThread.start();
            try {
                //主线程睡眠五秒钟
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //结束子线程
            myThread.interrupt();
        }
    }
    
    class MyThread extends Thread {
        @Override
        public void run() {
        	//每隔一秒打印一次当前时间
            while (true) {
                System.out.println("-------" + new Date() + "----------");
                try {
                    sleep(1000);
                } catch (InterruptedException e) {
                    return;
                }
            }
        }
    }

执行结果：  
![输出结果][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L015c2t5OTg0_size_16_color_FFFFFF_t_70 4]

1.  join方法，合并某个线程，合并的线程执行结束，再开始执行当前线程。

package threadtest;
    
    public class TextJoin {
    
        public static void main(String[] args) {
            MyThread2 myThread2 = new MyThread2("myThread2");
            myThread2.start();
            try {
            	//合并myThread2线程
                myThread2.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            for (int i = 0; i < 5; i++) {
                System.out.println("i am main thread");
            }
        }
    }
    
    class MyThread2 extends Thread {
        MyThread2(String s) {
            super(s);
        }
    
        @Override
        public void run() {
            for (int i = 0; i < 5; i++) {
                System.out.println("i am " + getName());
                try {
                    sleep(1000);
                } catch (InterruptedException e) {
                    return;
                }
            }
        }
    }

执行结果：  
![执行结果][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L015c2t5OTg0_size_16_color_FFFFFF_t_70 5]

1.  yield方法，让出CPU，给其他线程执行的机会  
    示例：

package threadtest;
    
    public class TestYield {
        public static void main(String[] args) {
            MyThread3 t1 = new MyThread3("t1");
            MyThread3 t2 = new MyThread3("t2");
            t1.start();
            t2.start();
        }
    }
    
    class MyThread3 extends Thread{
        MyThread3 (String s){
            super(s);
        }
    
        @Override
        public void run() {
            for (int i = 0;i < 10;i++){
                System.out.println(getName() + ":   " + i);
                if(i % 3 == 0){
                    //被2整除则让出CPU，给其他线程执行的机会
                    yield();
                }
            }
        }
    }

执行结果：  
![执行结果][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L015c2t5OTg0_size_16_color_FFFFFF_t_70 6]  
可以看出一旦被3整除t1或者t2就会让出线程让对方执行。

### 五、线程的优先级 ###

1.  Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程。线程调度器按照线程的优先级决定调度哪个线程来执行。
2.  线程优先级用数字表示，范围从1到10，默认是5。

Thread.MIN_PRIORITY = 1;
    Thread.MAX_PRIORITY = 10;
    Thread.NORM_PRIORITY = 5;

1.  使用下面的方法获得或设置线程对象的优先级。

int getPriority();
    void setPriority(int priority);

示例：

package threadtest;
    
    public class TestPriority {
    
        public static void main(String[] args) {
            Thread t1 = new Thread(new T1());
            Thread t2 = new Thread(new T2());
            //t1的优先级设置为9
            t1.setPriority(Thread.NORM_PRIORITY + 4);
            t1.start();
            t2.start();
        }
    
    }
    
    class T1 implements Runnable {
    
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                System.out.println("T1   " + i);
            }
        }
    }
    
    class T2 implements Runnable {
    
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                System.out.println("T2  " + i);
            }
    
        }
    }

执行结果：  
![运行结果][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L015c2t5OTg0_size_16_color_FFFFFF_t_70 7]  
由此可见，线程优先级越高越早执行而且执行的时间片越多，反之，越晚执行。  
[Java多线程机制（二）][Java]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L015c2t5OTg0_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20190922121728191.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L015c2t5OTg0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L015c2t5OTg0_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20190922122317805.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L015c2t5OTg0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L015c2t5OTg0_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20190922123314937.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L015c2t5OTg0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L015c2t5OTg0_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20190922124305476.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L015c2t5OTg0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L015c2t5OTg0_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20190922154700693.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L015c2t5OTg0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L015c2t5OTg0_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20190922160843502.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L015c2t5OTg0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L015c2t5OTg0_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20190922164225240.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L015c2t5OTg0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L015c2t5OTg0_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20190922170559926.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L015c2t5OTg0,size_16,color_FFFFFF,t_70
[Java]: https://blog.csdn.net/Mysky984/article/details/101165726