Java多线程入门

最新推荐文章于 2023-06-14 17:20:14 发布
最新推荐文章于 2023-06-14 17:20:14 发布
阅读量152 收藏
点赞数
分类专栏： 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44848573/article/details/115646260
版权

我是阿福，公众号「JavaClub」作者，一个在后端技术路上摸盘滚打的程序员，在进阶的路上，共勉！

文章已收录在 JavaSharing 中，包含Java技术文章，面试指南，资源分享。

Java多线程入门

文章主要涉及线程的启动，如何使多线程暂停，如何使多线程停止，线程的优先级级线程安全相关的问题。

1.1 进程和多线程的概念及线程的优点

进程：进程是操作系统结构的基础，是一次程序的执行，是一个程序及其数据在处理机上顺序执行时所发生的活动，是程序在一个数据集合上运行的过程，它是系统进行资源分配和调度的独立单位。（来源：百度百科）

看了这段话是不是十分抽象，不好理解，但是如果你看到图所示的内容，你还对进程不理解吗？ NO, NO, NO

难道一个正在操作系统中运行的exe程序可以理解成一个进程吗？没错！是他！是他！就是他！

那么在Windows任务管理器列表中，完全可以将运行在内存中的exe文件理解成进程，进程是受操作系统管理的基本运行单元。

那什么是线程呢？

线程可以理解成是进程中独立运行的子任务，比如 QQ.exe运行时有好多子任务在同时运行。比如：视频聊天线程，下载文件线程，传输数据线程等。这些不同的任务完全可以同时在运行，其中每一项任务可以理解成不同的线程在工作。

那么这样的优点是什么呢？例如我们使用多任务操作系统Windows后，可以最大限度地利用CPU的空闲时间来处理其他的任务，比如一边让操作系统处理正在由打印机打印的数据，一边使用Word编辑文档，而CPU在这些任务之间不停地切换，由于速度非常快，给读者的感受就是这些任务似乎在同时运行。

为了更好理解多线程的优势，首先我们通过单利模型图来理解一下单任务的缺点。

任务1和任务2是两个完全独立，互不相干的任务，任务一是在等待远程服务器返回数据，以便进行后期的处理，这是CPU一直处于等待状态，一直在空运行。而任务2一直处于等待状态必须等任务1返回数据才能运行，这样系统的运行效率大幅降低。单任务的特点就是排队执行，也就是同步，就像在cmd中输入一条命令后，必须等待这条命令执行完才可以执行下一条命令一样。所以单线程的缺点是：CPU利用率大幅降低。

从图中我们可以发现，CPU完全可以在任务1和任务2之间来回切换，使任务2不必等待10秒后再运行，系统的运行效率大大得到提升。

注意一点！！！！！

多线程是异步的，千万不要把IDEA里代码的顺序当成线程执行的顺序，线程被调用时随机的。

1.2 使用多线程

1.2.1 继承Thread类

在Java的JDK开发包中，已经自带了对多线程的支持，实现多线程编程的方式主要有两种：一种是继承Thread类，一种是实现Runable接口。

创建多线程之前我们先看看Thread的结构，如下：

public class Thread implements Runnable

从上面的源代码中我们可以发现，Thread类实现了Runnable接口，他们之间具有多态关系。

其实，使用继承Thread 类的方式实现多线程时，最大的局限性就是不支持多继承，因为在Java语言的特点就是单继承，所以为了实现多继承完全可以采用实现Runnable接口的方式。总的来说，没有什么本质的区别。

首先我们创建一个自定义的线程呢类 MyThread.java，继承Thread类并且重写run()方法，代码如下：

public class MyThread extends Thread{
    @Override
    public void run() {
        System.out.println("MyThread");
    }
}

运行类代码如下：

public class Test {
    public static void main(String[] args) {
        MyThread myThread=new MyThread();
        myThread.start();
        System.out.println("运行结束");
    }
}

运行结果如下：

运行结束 MyThread

从运行的结果来看， MyThread.java中的run方法执行的时间比较晚，这也说明在使用多线程技术时，代码的运行结果与代码执行顺序或调用顺序是无关的。

为什么会出现这样的结果呢？是因为线程是一个子任务，CPU以不确定的方式或是以随机的时间来调用线程中的run方法，所以会出现先打印 “ 运行结束 ”，后输出 “ MyThread” 这样的结果。

上面我们提出线程调用的随机性，下面我们创建MyThread.java 来演示线程的随机性。

创建自定义线程类MyThread.java，代码如下：

public class MyThread extends Thread {
    @Override
    public void run() {
        try {
            for (int i = 0; i < 5; i++) {
                int time = (int) Math.random() * 1000;
                Thread.sleep(time);
                System.out.println("run=" + Thread.currentThread().getName());
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}

再创建运行类Test.java,代码如下：

public class Test {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.setName("myThread");
        myThread.start();
        try {
            for (int i = 0; i < 5; i++) {
                int time = (int) Math.random() * 1000;
                Thread.sleep(time);
                System.out.println("main=" + Thread.currentThread().getName());
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}

代码运行结果：

main=main run=myThread main=main run=myThread main=main run=myThread main=main run=myThread main=main run=myThread

在代码中，为了展示线程具有随机性，所以使用随机数的形式来使线程得到挂起的效果，从而表现出CPU执行那个线程具有不确定性。

说明：MyThread.java中的start()方法通知“线程规划器”，此线程已经准别就绪，等待调用线程对象的run方法，这个过程其实就是让CPU安排一个时间来调用MyThread.java类中的run方法，也就是使线程得到运行。

在强调一点，执行start()方法的顺序不代表线程启动的顺序，创建测试类说明一下，代码如下：

public class MyThread extends Thread {
    private int i;

    public MyThread(int i) {
        this.i = i;
    }

    @Override
    public void run() {
        System.out.println("i=" + i);

    }
}

运行类Test.java,代码如下：

public class Test {
    public static void main(String[] args) {
        MyThread myThread1 = new MyThread(1);
        MyThread myThread2 = new MyThread(2);
        MyThread myThread3 = new MyThread(3);
        MyThread myThread4 = new MyThread(4);
        MyThread myThread5 = new MyThread(5);
        myThread1.start();
        myThread2.start();
        myThread3.start();
        myThread4.start();
        myThread5.start();
    }

程序运行后的结果如图：

i=1 i=2 i=5 i=3 i=4

1.2.2 实现Runnable接口

如果我们创建的线程类已经有一个父类了，这时候就不能继承Thread类了，因为在Java中不支持多继承，所以我们需要实现Runnable接口来实现多线程。

创建一个实现Runnable接口的类

public class MyRunnable implements Runnable{

    @Override
    public void run() {
        System.out.println("运行中！！！！！");
    }
}

如何使用MyRunnable.java类呢，我们看一下Thread.java类的构造函数，如下图所示：

在Thread.java类中的8个构造函数中，有两个构造函数Thread(Runnable target)和Thread(Runnable target, String name)可以传递Runnable接口，说明构造函数支持传入一个Runnable接口的对象，运行类代码如下：

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

运行结果如图：

运行结束！！！ 运行中！！！！！

另外需要说明一点，Thread.java类也是实现Runnable接口，如下：

public class Thread implements Runnable

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

1.2.3 实例变量与线程安全

自定义线程类中的实例变量针对其他线程可以有共享和不共享之分，下面我们分开来说明这两点：

不共享数据的情况：

不共享数据的情况如下图展示说明：

下面我们通过一个示例来看下数据不共享情况，创建一个MyThread.java类代码如下：

public class MyThread extends Thread {
    private int count = 5;

    public MyThread(String name) {
        this.setName(name);
    }

    @Override
    public void run() {
        while (count > 0) {
            count--;
            System.out.println("由 " + this.currentThread().getName() + " " + "计算, count " + count);
        }
    }
}

运行类Test.java代码如下：

public class Test {
    public static void main(String[] args) {
        MyThread myThread=new MyThread("A");
        MyThread myThread1=new MyThread("B");
        MyThread myThread2=new MyThread("C");
        myThread.start();
        myThread1.start();
        myThread2.start();
    }
}

不共享数据运行结果如下：

由 B 计算, count 4 由 C 计算, count 4 由 A 计算, count 4 由 C 计算, count 3 由 B 计算, count 3 由 C 计算, count 2 由 A 计算, count 3 由 C 计算, count 1 由 B 计算, count 2 由 C 计算, count 0 由 A 计算, count 2 由 B 计算, count 1 由 A 计算, count 1 由 B 计算, count 0 由 A 计算, count 0

我们总共创建了3个线程，每个线程都有各自的count变量，自己减少自己的count变量的值，这样的情况就是变量不共享。

那么，如果想实现3个线程共同对一个count变量进行减法操作的目的，该如何设计呢？

共享数据的情况

共享数据的情况如下图：

共享数据的情况就是多个线程同时访问一个变量，比如实现投票功能的软件时，多个线程可以同时处理同一个人的票数。

下面我们通过代码实例演示一下共享数据的情况，创建一个MyThread.java类代码如下：

public class MyThread extends Thread {
    private int count = 3;

    @Override
    public void run() {
        count--;
        System.out.println("由 " + this.currentThread().getName() + " " + "计算, count " + count);

    }
}

运行类Test.java代码如下：

public class Test {
    public static void main(String[] args) {
        MyThread myThread=new MyThread();
        Thread thread=new Thread(myThread,"A");
        Thread thread1=new Thread(myThread,"B");
        Thread thread2=new Thread(myThread,"C");
        thread.start();
        thread1.start();
        thread2.start();
    }
}

运行结果：

由 A 计算, count 0 由 C 计算, count 0 由 B 计算, count 0

从运行结果我们可以看出，线程A，线程B，线程C 的count值都是2，说明A,B,C同时对count进行处理，产生了“非线程安全”的问题。

那我们修改代码如下 即在run() 方法前面加上synchronized关键字：

public synchronized void run() {
    count--;
    System.out.println("由 " + this.currentThread().getName() + " " + "计算, count " + count);
}

重新运行程序就不回产生值一样的情况了，结果显示如下：

由 A 计算, count 2 由 C 计算, count 1 由 B 计算, count 0

​ 通过在run()方法前面加上synchronized关键字，使多个线程在执行run()方法时，以排队的形式进行处理。但一个线程调用run前，先判断run方法有没有被上锁，如果上锁，说明有其他线程正在调用run方法，必须等其他线程对run方法调用结束后才可以执行run方法。这样排队调用run方法的目的，也就达到按顺序对count变量减1的效果了。同时synchronized可以在任何方法上加锁，而加锁的这段代码叫做“互斥区” 或“临界区”。

另外说明，当一个线程想要执行同步方法里面的代码时，线程首先去拿这把锁，如果能够拿到这把锁，那么这个线程就可以执行synchronized如果拿不到这把锁，那么线程就不断的尝试拿这把锁，直到能够拿到为止。

这里我们引出一个概念，“非线程安全”。非线程安全主要是指多个线程对同一个对象中的同一个实例变量进行操作时会出现值被更改，值不同步的情况，进而影响程序的执行流程。

下面我们来实现一个非线程安全的实例，loginServlet.java代码如下：

public class loginServlet {
    private static String usernameRef;
    private static String passwordRef;

    public static void doPost(String username, String password) {
        try {
            usernameRef = username;
            if (username.equals("username=" + username)) {
                Thread.sleep(5000);
            }
            passwordRef = password;
            System.out.println("username=" + usernameRef + " " + " password=" + passwordRef);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}

线程ALogin.java代码如下：

public class ALogin extends Thread{
    @Override
    public void run() {
       loginServlet.doPost("a","aa");
    }
}

线程BLogin.java代码如下：

public class BLogin extends Thread{
    @Override
    public void run() {
       loginServlet.doPost("b","bb");
    }
}

代码实例运行结果：

username=a password=bb username=b password=bb

由运行结果我们可以看出，出现了线程不安全的问题，解决这个问题的方法我们使用synchronized关键字修饰别调用的方法即可。

public static synchronized void doPost(String username, String password)

1.3 多线程常用方法

1.3.1 CurrentThread() 方法

CurrentThread() 方法返回代码段正在被哪个线程调用的信息，下面通过一个示例来说明：

public class Test {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName());
    }
}

运行结果：

main

结果说明，main 方法被名为main的线程调用。

继续实验，创建 MyThread.java代码如下：

public class MyThread extends Thread {
    public MyThread() {
        System.out.println("构造方法的打印："+Thread.currentThread().getName());
        this.setName("MyThread");
    }

    @Override
    public void run() {
        System.out.println("run方法的打印："+Thread.currentThread().getName());
    }
}

运行类Test.java代码如下：

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

运行结果：

构造方法的打印：main run方法的打印：MyThread

从运行结果我们可以发现，MyThread.java类的构造函数是被main线程调用的，而run方法是被名称为MyThread的线程调用的。

1.3.2 isAlive()方法

方法isAlive()的功能是判断当前的线程是否处于活动状态。

创建 MyThread.java代码如下：

public class MyThread extends Thread {

    @Override
    public void run() {
        System.out.println("run="+this.isAlive());
    }
}

运行类Test.java代码如下：

public class Test {
    public static void main(String[] args) {
        MyThread myThread=new MyThread();
        System.out.println("begin==" + myThread.isAlive());
        myThread.start();
        // Thread.sleep(1000);
        System.out.println("end==" + myThread.isAlive());
    }
}

运行结果：

begin==false end==true run=true

方法isAlive()的作用是测试线程是否处于活动状态，那什么是活动状态呢？活动状态就是线程已经启动且尚未终止。即线程处于正在运行或准备开始运行的状态，就认为线程是存活的。

说明一下，如下代码：

System.out.println("end==" + myThread.isAlive());

虽然上面打印的值是true,但是此值是不确定的，打印true是因为MyThread线程还未执行完毕，所以输出true,如果修改代码把Test.java中 Thread.sleep(1000)代码放开，运行结果输出是false,因为MyThread线程在1秒内就执行完毕。

另外，在使用isAlive()方法时，如果将线程对象以构造函数的方式传递给Thread对象进行start()启动时，运行的结果和前面的实例是有差异的，造成这样差异的原因是来自于Thread.currentThread()和this的差异。

1.3.3 sleep() 方法

方法sleep()的作用是在指定的毫秒数内让当前“ 正在执行的线程”休眠（）暂停执行，这个正在执行的线程是指this.currentThread()返回的线程，前面的实例也提到过，这里代码不做说明。

1.3.4 getId() 方法

getId() 方法的作用是取得线程的唯一的唯一标示。

运行类Test.java代码如下：

public class Test {
    public static void main(String[] args) throws InterruptedException {
        System.out.println(Thread.currentThread().getName()+ ":"+ Thread.currentThread().getId());
    }
}

运行结果：

main: 1

1.3.5 yield()方法

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

创建 MyThread.java代码如下：

public class MyThread extends Thread {

    @Override
    public void run() {
        long beginTime = System.currentTimeMillis();
        int count = 0;
        for (int i = 0; i < 1000000; i++) {
            //Thread.yield();
            count+=count;
        }
        long endTime = System.currentTimeMillis();
        System.out.println("用时："+(endTime-beginTime)+ "毫秒！");
    }
}

运行类Test.java代码如下：

public class Test {
    public static void main(String[] args) throws InterruptedException {
        MyThread myThread=new MyThread();
        myThread.start();
    }
}

程序运行后结果：

用时：3毫秒！

去掉注释代码，再次运行，结果如下：说明将CPU让给其他资源导致速度变慢。

用时：323毫秒！

1.4 停止线程

停止一个线程意味着在线程处理完任务之前停掉正在做的操作，也就是放弃当前的操作。

在Java中有一下三种方式可以终止正在运行的线程：

  • 使用退出标示，使线程正常退出，也就是当run方法完成后线程终止。
  • 使用stop方法强行终止线程，因为stop和suspend及resume一样，都是作废的方法，使用起来起来kennel产生不可预料的结果。
  • 使用interrupt方法中断线程（常用）

大多数停止一个线程的操作使用Thread.interrupt()方法，尽管方法的名称是“ 停止，中止”的意思，但是这个方法不会停止一个正在运行的线程，还需要加入一个判断才可以完成线程的停止操作。

1.4.1 停止不了的线程

使用interrupt()方法停止线程，但是interrupt()放大不像for+break语句那样，可以马上就停止循环，调用interrupt()方法仅仅是在当前线程中打了一个停止的标记，并不是真正的停止线程。

创建 MyThread.java代码如下：

public class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i <= 10000; i++) {
            System.out.println("i="+i);
        }
    }
}

运行类Test.java代码如下：

public class Test {
    public static void main(String[] args) throws InterruptedException {
        MyThread myThread=new MyThread();
        myThread.start();
        myThread.interrupt();
    }
}

部分运行结果：

i=9997 i=9998 i=9999 i=10000

从运行的结果来看，调用interrupt方法并没有停止线程，那么如何停止线程呢？

1.4.2 判断线程是否是停止状态

判断线程的状态是不是停止的，在Java的JDK中，Thread.java类中提供了两种方法：

this.isInterrupted()：测试当前线程是否已经中断。 this.isInterrupted(); 测试线程是否已经中断。

public static boolean interrupted() 
public boolean isInterrupted()

一个是静态的方法一个不是静态的方法。

下面我们说明如何是main线程产生中断的效果呢？ 创建Test.java类，代码如下：

public class Test {
    public static void main(String[] args) throws InterruptedException {       
        Thread.currentThread().interrupt();
        System.out.println("是否停止1："+Thread.interrupted());
        System.out.println("是否停止2："+Thread.interrupted());
    }
}

程序运行后结果：

是否停止1：true 是否停止2：false

从运行的结果来看，interrupted方法判断当前线程是否是停止状态。但是为什么第二个布尔值为false呢，这是由于 interrupted方法有清除状态的功能，所以第二次调用的返回值是false。而isInterrupted判断线程是否中断不清除状态标示。

接下来我们通过一个示例来说明如何停止一个线程，创建 MyThread.java代码如下：

public class MyThread extends Thread {

    @Override
    public void run() {
        int count = 0;
        while (!Thread.currentThread().isInterrupted()) {
            count++;
        }
        System.out.println("循环次数：" + count + "，线程中断，中断信号：" + Thread.currentThread().isInterrupted());

    }
}

创建Test.java类，代码如下：

public class Test {
    public static void main(String[] args) throws InterruptedException {
        MyThread myThread=new MyThread();
        myThread.start();
        Thread.sleep(5);
        myThread.interrupt();

    }
}

程序运行结果：

循环次数：88528，线程中断，中断信号：true

以上结果可以看到循环 88528 次后，线程收到了中断信号（即 Thread.currentThread().isInterrupted() 返回的结果为 true），循环条件不满足条件，退出循环，执行完程序，自动停止线程，这种就属于通过 interrupt 正确停止线程的情况。

1.5 暂停线程

1.5.1 suspend与resume方法的使用

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

创建 MyThread.java代码如下：

public class MyThread extends Thread {
    private  long i=0;

    public long getI() {
        return i;
    }

    public void setI(long i) {
        this.i = i;
    }

    @Override
    public void run() {
      while (true){
          i++;
      }
    }
}

创建Test.java类，代码如下：

public class Test {
    public static void main(String[] args) throws InterruptedException {
        MyThread myThread=new MyThread();
        myThread.start();
        Thread.sleep(1000);
        //A段
        myThread.suspend();
        System.out.println("A= "+System.currentTimeMillis()+ " i="+myThread.getI());
        Thread.sleep(1000);
        System.out.println("A= "+System.currentTimeMillis()+ " i="+myThread.getI());

        myThread.resume();
        Thread.sleep(1000);

        myThread.suspend();
        System.out.println("B= "+System.currentTimeMillis()+ " i="+myThread.getI());
        Thread.sleep(1000);
        System.out.println("B= "+System.currentTimeMillis()+ " i="+myThread.getI());
    }
}

程序运行结果：

A= 1618220660051 i=690427887 A= 1618220661056 i=690427887 B= 1618220662061 i=1410759540 B= 1618220663066 i=1410759540

从程序运行结果来看，线程的确是被暂停了，而且还可以恢复成运行的状态。

1.6 线程的优先级

在操作系统中，线程可以划分优先级，优先级较高的线程得到CPU资源较多，也就是CPU优先执行优先级较高的线程对象中的任务。

设置线程优先级有助于“线程规划器”，确定下一次选择哪个线程来优先执行。

设置线程优先级使用setPriority() 方法，此方法在JDK的源代码如下：

public final void setPriority(int newPriority) {
    ThreadGroup g;
    checkAccess();
    if (newPriority > MAX_PRIORITY || newPriority < MIN_PRIORITY) {
        throw new IllegalArgumentException();
    }
    if((g = getThreadGroup()) != null) {
        if (newPriority > g.getMaxPriority()) {
            newPriority = g.getMaxPriority();
        }
        setPriority0(priority = newPriority);
    }
}

在Java中，线程优先级分为 1～～10这10个等级，如果小于1或者大于10，则JDK抛出异常为 throw new IllegalArgumentException()

public final static int MIN_PRIORITY = 1;
public final static int NORM_PRIORITY = 5;
public final static int MAX_PRIORITY = 10;
1.6.1 优先级的继承特性

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

创建 MyThread1.java代码如下：

public class MyThread1 extends Thread{
    @Override
    public void run() {
        System.out.println("MyThread1 run Priority="+this.getPriority());
        MyThread2 myThread2=new MyThread2();
        myThread2.start();
    }
}

创建 MyThread2.java代码如下：

public class MyThread2 extends Thread{
    @Override
    public void run() {
        System.out.println("MyThread2 run Priority="+this.getPriority());
    }
}

创建Test.java类，代码如下：

public class Test {
    public static void main(String[] args) {
        System.out.println(" main thread begin  priority="+Thread.currentThread().getPriority());
        //Thread.currentThread().setPriority(8);
        System.out.println(" main thread end priority="+Thread.currentThread().getPriority());
        MyThread1 myThread1=new MyThread1();
        myThread1.start();
    }
}

运行结果：

main thread begin priority=5 main thread end priority=5 MyThread1 run Priority=5 MyThread2 run Priority=5

将代码 Thread.currentThread().setPriority(8) 的注释去掉，再次运行Test.java文件，显示如下：

main thread begin priority=5 main thread end priority=8 MyThread1 run Priority=8 MyThread2 run Priority=8

1.6.2 优先级具有规则性

虽然使用setPriority()方法可以设置线程的优先级，但还没有看到设置优先级带来的效果。

创建 MyThread1.java代码如下：

public class MyThread1 extends Thread{
    @Override
    public void run() {
        long beginTimeMillis = System.currentTimeMillis();
        long addResult=0;
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 50000; j++) {
                Random random=new Random();
                random.nextInt();
                addResult=addResult+j;
            }
        }
        long endTimeMillis = System.currentTimeMillis();
        System.out.println( " @@@@@@@@@@@@@@@@@@  thread 1 use time =  "+ (endTimeMillis-beginTimeMillis) );
    }
}

创建 MyThread2.java代码如下：

public class MyThread2 extends Thread{
    @Override
    public void run() {
        long beginTimeMillis = System.currentTimeMillis();
        long addResult=0;
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 50000; j++) {
                Random random=new Random();
                random.nextInt();
                addResult=addResult+j;
            }
        }
        long endTimeMillis = System.currentTimeMillis();
        System.out.println( " @@@@@@@@@  thread 2 use time =  "+ (endTimeMillis-beginTimeMillis) );
    }
}

创建Test.java类，代码如下：

public class Test {
    public static void main(String[] args) {
        for (int i = 0; i <5 ; i++) {
            MyThread1 myThread1=new MyThread1();
            myThread1.setPriority(10);
            myThread1.start();
            MyThread2 myThread2=new MyThread2();
            myThread2.setPriority(1);
            myThread2.start();
        }

    }
}

程序运行的结果：

@@@@@@@@@@@@@@@@@@ thread 1 use time = 412 @@@@@@@@@ thread 2 use time = 426 @@@@@@@@@@@@@@@@@@ thread 1 use time = 438 @@@@@@@@@ thread 2 use time = 449 @@@@@@@@@@@@@@@@@@ thread 1 use time = 449 @@@@@@@@@@@@@@@@@@ thread 1 use time = 455 @@@@@@@@@ thread 2 use time = 459 @@@@@@@@@ thread 2 use time = 461 @@@@@@@@@@@@@@@@@@ thread 1 use time = 462 @@@@@@@@@ thread 2 use time = 463

从运行的结果我们发现，高优先级的线程总是大部分先执行完，但不代表优先级高的全部执行完。另外，不要以为MyThread1线程先被main线程调用就先执行完，出现这样的结果是因为MyThread1线程的优先级高。当线程优先级差距较大时，谁先执行完和代码的调用顺序无关。同时说明线程的优先级具有一定的规则性，也就是CPU尽量将执行资源让给优先级比较高的线程。

1.6.3 优先级具有随机性

因为优先级具有随机性，也就是优先级比较高的线程不一定每一次都先执行完。

我们将上面Test.java类代码myThread2.setPriority(5)，运行代码结果如下：

@@@@@@@@@@@@@@@@@@ thread 1 use time = 440 @@@@@@@@@@@@@@@@@@ thread 1 use time = 464 @@@@@@@@@@@@@@@@@@ thread 1 use time = 465 @@@@@@@@@ thread 2 use time = 466 @@@@@@@@@ thread 2 use time = 472 @@@@@@@@@ thread 2 use time = 473 @@@@@@@@@ thread 2 use time = 475 @@@@@@@@@@@@@@@@@@ thread 1 use time = 476 @@@@@@@@@ thread 2 use time = 476 @@@@@@@@@@@@@@@@@@ thread 1 use time = 476

那么，我们得出一个结论，不要把线程的优先级与运行结果的顺序作为衡量的标准，优先级较高的不一定每一次都先执行完。也就是说优先级与打印的顺序无关，因为它们的关系具有不确定性和随机性。

1.7 守护线程

在Java线程中有两种线程，一种是用户线程，另一种是守护线程。

守护线程是一种特殊的线程，它的特性有“陪伴”的含义，当进程中不存在非守护线程了。则守护线程自动销毁。典型的守护线程就是垃圾回收线程。

通俗的说：“守护线程”：任何守护线程都是整个JVM中非守护线程的“保姆”，只有当前JVM实例中存在任何一个非守护线程没有结束，守护线程就在工作，只有当最后一个非守护线程结束时，守护线程才随JVM一同结束工作。Daemon的作用是为其他线程的运行提供便利服务，守护线程最典型的应用就是GC(垃圾回收器)。

创建 MyThread.java代码如下：

public class MyThread extends Thread {
    private  int i=0;
    @Override
    public void run() {
        try {
            while (true){
                i++;
                System.out.println("i= "+i);
                Thread.sleep(1000);
            }
        }catch(InterruptedException e){
            e.printStackTrace();
        }

    }
}

创建Test.java类，代码如下：

public class Test {
    public static void main(String[] args) throws  InterruptedException{
       MyThread myThread=new MyThread();
       myThread.setDaemon(true);
       myThread.start();
       Thread.sleep(5000);
        System.out.println("我离开 myThread 对象也不打印了，也停止了");
    }
}

程序运行的结果：

i= 1 i= 2 i= 3 i= 4 i= 5 我离开 myThread 对象也不打印了，也停止了

看到这里今天的分享就结束了，如果觉得这篇文章还不错，来个分享、点赞、在看三连吧，让更多的人也看到～

欢迎关注个人公众号 「JavaClub」，定期为你分享一些技术干货。

java多线程入门
06-13
### Java多线程入门 #### 一、进程与线程的区别 在理解Java中的多线程之前，我们先来看看进程和线程之间的区别。 - **进程**：进程是程序的一次执行过程，它是系统进行资源分配和调度的一个独立单位。每个进程都...
JAVA多线程入门基础知识
02-22
必知必会的多线程入门基础知识
java多线程编程详细入门教程
liuyuanq123的博客
10-31 4万+
1、概念 &amp;amp;amp;amp;nbsp;&amp;amp;amp;amp;nbsp;&amp;amp;amp;amp;nbsp;&amp;amp;amp;amp;nbsp;&amp;amp;amp;amp;nbsp;线程是jvm调度的最小单元，也叫做轻量级进程，进程是由线程组成，线程拥有私有的程序技术器以及栈，并且能够访问堆中的共享资源。这里提出一个问题，为什么要用多线程？有一下几点，首先，随着cpu核心数的增加，计算机硬件的并行计算能力得到提升，
Java 多线程入门
qq_43164662的博客
11-22 496
Java 多线程入门，了解多个线程是如何同时进行的。
Java多线程入门超详解(小白也可以看懂的）
qq_41257358的博客
05-10 3069
Java多线程入门超详解(小白也可以看懂的 一、名词详解1.1 进程和线程1.2 并行和并发1.3 同步和异同步1.4 临界资源和临界区二、为什么要用多线程三、线程的五种状态四、Java创建线程的两种方法1、继承Thread类2、实现Runnable接口五、Java线程的常用方法1、wait()和notify()2、sleep()，yield()，join()3、setPriority()六、sy...
java多线程入门例子-第一例
java 菜鸟一枚
09-18 3221
– 认识多线程-1 多线程运行顺序基础举例 多线程数据共享基本例子
Java多线程详解（一）Java多线程入门
刘成
11-27 2289
最近听很多面试的小伙伴说，网上往往是一篇一篇的Java多线程的文章，除了书籍没有什么学习多线程的一系列文章。但是仅仅凭借一两篇文章很难对多线程有系统的学习，而且面试的时候多线程这方面的知识往往也是考察的重点，所以考虑之下决定写一系列关于Java多线程的文章。文章参考了高老师的《Java多线程编程核心技术》。力争使用最短的篇幅把Java多线程的知识作以系统的讲述。 本节思维导图： 思维导图...
Java多线程入门(二)
qq_44525150的博客
06-07 2077
本文简要介绍了Java多线程中的线程同步的作用，实现线程同步的三种方法，什么是线程死锁，线程死锁的例子，线程的状态，线程的生命周期
Java多线程学习（吐血超详细总结）
热门推荐
Evankaka的专栏
03-14 42万+
本文主要讲了java中多线程的使用方法、线程同步、线程数据传递、线程状态及相应的一些线程函数用法、概述等。
Java多线程入门篇（三）Java线程间的通信（锁，等待/通知，信号量，管道）
wangdawei_的博客
02-28 853
java多线程入门篇 （三） 锁与同步等待/通知机制信号量：管道：其它通信相关join方法sleep方法ThreadLocal类InheritableThreadLocal   在Java中合理的使用多线程可以更好的利用服务器资源。一般来说，线程都有自己的自由线程上下文，互不干扰。但是当我们需要多个线程之间互相协作的时候，就需要掌握Java线程的通信方式才可以 锁与同步   在Java中锁都是基于对象的，所以又称为对象锁。锁与线程的关系就像婚姻关系，一个锁在同一时间只能由一个线程持有，只有当持有锁的线程释放
002-Java多线程入门学习
qq_40488788的博客
11-24 342
Java多线程入门学习 ​ 狂神说Java多线程模块总结篇-凡人就该保留偏执的权利-kxd@my.swjtu.edu.cn 一.线程，进程，多线程 程
编程必备：JAVA多线程详解
拾一二的博客
06-14 8628
多线程已经成为一种常见的编程模式，广泛应用于各种不同类型的应用程序中。本篇博客文章中，我们将会探讨多线程编程的相关知识和技巧。通过代码示例和实际应用案例来深入了解多线程的具体实现和应用方法，帮助更好地掌握多线程编程技术，提高程序效率和性能。后期随学习深入还会补充修改。以上就是我对多线程的个人简介，后续会不断完善更新，与大家共勉。
java多线程入门知识及示例程序
09-04
"Java多线程入门知识及示例程序" Java多线程是一种非常重要的编程技术，它可以帮助开发者创建高效、可扩展的程序。多线程的出现是为了解决某些问题，如图形界面的出现、输入、输出的阻塞和多核CPU的更好利用等。 ...
java多线程入门的源代码
03-28
Java多线程是Java开发中的重要概念，它允许程序同时执行多个任务，提高了程序的效率和响应速度。在Java中，实现多线程有两种主要方式：继承Thread类和实现Runnable接口。 1. 继承Thread类： 当一个类继承了Thread...
ioDraw-v3.1.0-win64.exe，流程图、思维导图、甘特图绘制软件，Windows64位免安装版
11-10
1、ioDraw 是免费的在线作图软件，用于制作流程图、思维导图、甘特图、白板手绘图、mermaid流程图、海报设计、折线图、柱状图、拓扑图、组织结构图、UML、ER和时序图、平面设计图、电子电路图等，无需注册即可使用 2、替代Visio的免费软件，无使用限制 3、适合程序员、白领、系统架构师、项目经理、平面设计师、产品经理使用 4、v3.1.0变更日志： 新增将文件保存到百度网盘。 修复第三方平台文件列表页显示问题。
基于Java+SpringBoot+Vue的高校心理健康评测与服务系统答辩PPT.pptx
最新发布
11-10
基于Java+SpringBoot+Vue的高校心理健康评测与服务系统答辩PPT.pptx
【光学】基于matlab BP神经网络光纤光栅应变传感器温度补偿【Matlab仿真 8783期】.zip
11-10
【光学】基于matlab BP神经网络光纤光栅应变传感器温度补偿【Matlab仿真 8783期】.zip
易支付完美级别运营已对接小微商户带视频教程
11-10
搭建非常简单真实可用 完美级别运营首选 已去授权已对接微信小微商户接口 支持扫码 jsapi 小程序 php 扩展安装:sg11 对接易通商户 需要开启PHP7.0以上 已全部开源
智能车未来趋势解析：技术进展、挑战及发展路径
11-10
内容概要：该文综述了21世纪智能车技术的发展现状及其面临的关键挑战。首先概述了智能车的基础技术构成，包括自动驾驶技术、车联网技术和智能座舱等组成部分。随后详细讨论了智能车技术实现的重要步骤：感知系统的开发、决策与控制的设计及系统的集成测试过程。此外，文中还指出了技术、法规及社会三个方面的主要挑战，并提出相应的发展策略建议。全文旨在探索未来智能车发展方向。 适用人群：对智能车技术及其应用感兴趣的汽车行业专业人员、技术研发人员及政策研究人士等。 使用场景及目标：适合用于了解智能车领域最新发展趋势和技术壁垒，辅助企业技术创新、产品规划及政府制定相关政策。 其他说明：本文对于希望把握智能车未来发展脉络，参与或者推动该领域进步的相关群体有着重要的指导意义。
Java多线程入门与线程安全
"这篇资料是关于Java多线程的学习材料，由高级软件人才实作培训专家北京传智播客教育提供，由讲师毕向东讲解。资料涵盖了多线程的基础概念，如进程、线程的创建与状态，以及线程安全问题和同步机制。" Java多线程是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值