Thread基础还不明白？还不快和我一起学

最新推荐文章于 2024-05-04 07:21:52 发布
最新推荐文章于 2024-05-04 07:21:52 发布
阅读量1w 收藏 2
点赞数 3
分类专栏： Java基础 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WODESHENNI/article/details/105689536
版权

文章目录

内容简介

1）线程的启动；
2）如何使线程暂停；
3）线程的优先级；
4）线程安全相关的问题

1.1 进程和线程是什么？多线程又有什么好处呢？

进程：受操作系统管理的基本运行单元。
线程：进程中独立运行的子任务。

图1-1-1，单任务的特点：排队执行，也就是同步。这就是单任务环境的缺点，CPU利用率大幅降低。
图1-1-2，CPU完全可以再任务1与任务2之间来回切换，使任务2不必等待任务1执行完毕再进行，系统的运行效率大大提升。
在这里插入图片描述

1.2 怎么使用多线程

实现多线程的的方式有两种，一种是继承Thread类，另一种是实现Runnable接口。

1.2.1 方式一：继承Thread类

public class Thread implements Runnable{}

使用继承Thread类的方式来创建多线程时，最大的局限性就是不支持多继承（Java语言的特点就是单根继承）。下面使用第一种方式，继承Thread类。

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

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

运行结束
MyThread

从执行结果来看，MyThread类中run方法执行的时间较晚，这也说明在使用多线程技术时，代码的运行结果与代码的执行顺序或调用顺序是无关的。线程是一个子任务，CPU以不确定的方式，或者说是以随机的时间来调用线程中的run方法，所以就会出现如上结果。 如果多次调用start()，则会出现 Exception in thread "main" java.lang.IllegalThreadStateException。

上面介绍了线程调用的随机性，下面我们再演示线程的随机性，如下。

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();
        }
    }
}

public class Run{
    public static void main(String[] args) {
        try {
            MyThread myThread =new MyThread();
            myThread.setName("MyThread");
            myThread.start();
            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.fillInStackTrace();
        }
    }
}


run=MyThread
main=main
main=main
run=MyThread
run=MyThread
main=main
run=MyThread
run=MyThread
main=main
main=main

继承Thread，重写run方法，调用start方法执行线程的流程：

调用Thread类中的start方法通知线程规划器此线程已经准备就绪，等待调用线程对象的run方法。这个过程其实就是让系统安排一个时间来调用Thread中的run方法，使线程得到运行，线程为异步执行；如果直接调用Thread.run()，那么此线程对象并不交给“线程规划器”来处理，而是由main主线程来调用run()，也就是同步执行。

1.2.2 方式二：实现Runnable接口

如果预创建的线程类已经有一个父类了，这时候就不能再继承Thread了，因为Java不支持多继承，所以就需要实现Runnbale接口来应对这种情况。 如何使用Runnable接口呢，那么就要看一下Thread的构造函数了。

public Thread()
public Thread(Runnable target)
public Thread(ThreadGroup group, Runnable target)
public Thread(String name)
public Thread(ThreadGroup group, String name)
public Thread(Runnable target, String name)
public Thread(ThreadGroup group, Runnable target, String name)
public Thread(ThreadGroup group, Runnable target, String name, long stackSize)

在Thread类的8个构造函数中，有两个个构造函数

public Thread(Runnable target)
public Thread(Runnable target, String name)

简单写个示例如下：

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("running");
    }
}

public class RunMyRunnable{
    public static void main(String[] args) {
        Thread thread  =new Thread(new MyRunnable());
        System.out.println(thread.getName());
        thread.start();
        Thread thread2  =new Thread(new MyRunnable(),"customize name");
        System.out.println(thread2.getName());
        thread2.start();
        System.out.println("运行结束");
    }
}


Thread-0
customize name
运行结束
running
running

1.2.3 实例变量与线程安全

自定义线程类中的实例变量针对其他线程有共享和不共享之分，这在多线程之间进行交互时是很重要的一个技术点。

1.2.3.1 不共享数据的情况
public class MyThread extends Thread{
    private int count =5;
    public MyThread(String name) {
        this.setName(name);
    }
    @Override
    public void run() {
        super.run();
        while (count >0) {
            count--;
            System.out.println("由" +this.currentThread().getName() +"计算，count=" +count);
        }
    }
}

public class Run{
    public static void main(String[] args) {
        MyThread myThreadA =new MyThread("myThreadA");
        MyThread myThreadB =new MyThread("myThreadB");
        MyThread myThreadC =new MyThread("myThreadC");
        myThreadA.start();
        myThreadB.start();
        myThreadC.start();
    }
}

由myThreadA计算，count=4
由myThreadC计算，count=4
由myThreadC计算，count=3
由myThreadC计算，count=2
由myThreadC计算，count=1
由myThreadC计算，count=0
由myThreadA计算，count=3
由myThreadA计算，count=2
由myThreadA计算，count=1
由myThreadA计算，count=0
由myThreadB计算，count=4
由myThreadB计算，count=3
由myThreadB计算，count=2
由myThreadB计算，count=1
由myThreadB计算，count=0
1.2.3.2 共享数据的情况

共享数据是指多个线程同时访问同一个变量。

public class MyThread extends Thread{
    private int count =5;
    @Override
    public void run() {
        super.run();
        count--;
        System.out.println("由" +this.currentThread().getName() +"计算，count=" +count);
    }
}

public class Run{
    public static void main(String[] args) {
        MyThread myThreadA =new MyThread();
        Thread a =new Thread(myThreadA,"A");
        Thread b =new Thread(myThreadA,"B");
        Thread c =new Thread(myThreadA,"C");
        Thread d =new Thread(myThreadA,"D");
        Thread e =new Thread(myThreadA,"E");
        a.start();
        b.start();
        c.start();
        d.start();
        e.start();
    }
}

由C计算，count=3
由B计算，count=3
由A计算，count=2
由E计算，count=1
由D计算，count=0

线程C和B打印出的count值都是3，说明A和B同时获取到count并进行–的操作，产生了非线程安全问题。count–的操作分成三步：
1）取得原有count值；
2）计算count-1；
3）对count赋值。
如果多个线程同时访问，一定会出现非线程安全问题。

那么如何解决上面的线程安全问题呢？这时就需要使多个线程之间进行同步。更改MyThread类代码如下：

public class MyThread extends Thread{
    private int count =5;
    @Override
    synchronized public void run() {
        super.run();
        count--;
        System.out.println("由" +this.currentThread().getName() +"计算，count=" +count);
    }
}

由A计算，count=4
由E计算，count=3
由B计算，count=2
由D计算，count=1
由C计算，count=0

运行之后，执行结果与预期一致。通过在run方法前加入synchronized，使多个线程在执行run方法时，以排队的方式进行处理。当一个线程调用run前，先判断run方法有没有被上锁，如果上锁，说明有其他线程正在调用run方法，必须等其他线程对run方法调用结束之后才可以执行。这样也就实现了排队调用run方法的目的。synchronized可以在任意对象及方法上加锁，而加锁的这段代码成为互斥区或临界区。

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

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

下面来实现一个非线程安全导致的后果。

public class LoginServlet{
    private static StringuserNameRef;
    private static StringpasswordRef;
    public static void login(String userName, String password) {
        userNameRef = userName;
        try {
            if (userName.equals("a")) {
                Thread.sleep(5000);
            }
            passwordRef = password;
            System.out.println("当前的用户名：" +userNameRef +" 密码：" +passwordRef);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}


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

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

public class DoLogin{
    public static void main(String[] args) {
        ALogin a =new ALogin();
        a.start();
        BLogin b =new BLogin();
        b.start();
    }
}

当前的用户名：b 密码：bb
当前的用户名：b 密码：aa

解决这个非线程安全的方法也是使用synchronized，更改代码如下：

public class LoginServlet{
    private static StringuserNameRef;
    private static StringpasswordRef;
    synchronized public static void login(String userName, String password) {
        userNameRef = userName;
        try {
            if (userName.equals("a")) {
                Thread.sleep(5000);
            }
            passwordRef = password;
            System.out.println("当前的用户名：" +userNameRef +" 密码：" +passwordRef);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

当前的用户名：a 密码：aa
当前的用户名：b 密码：bb

1.3 currentThread()

currentThread方法可返回代码段正在被哪个线程调用的信息。

1.4 isAlive()

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

1.5 sleep()

在指定得毫秒数内让当前“正在执行的线程”休眠（暂停执行）。这个“正在执行的线程”是指this.currentThread()返回的线程。

1.6 getId()

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

1.7 停止线程

停止一个线程意味着在线程处理完任务之前停掉正在做的操作。虽然看起来很简单，但是必须做好防范措施，以便达到预期效果。
在Java中有三种方法可以终止正在运行的线程：
1）使用退出标志，使线程正常退出，也就是当run方法完成后线程终止。
2）使用stop方法（已经被作废）强行终止线程。不推荐使用此方法，因为stop和susped、resume一样都是作废过期的方法。
3）使用interrupt方法中断线程。

1.7.1 停止不了的线程

interrupt方法仅是在当前线程中打了一个停止的标记，并不是真的停止线程。

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

public class Run{
    public static void main(String[] args) {
        MyThread thread =new MyThread();
        thread.start();
        thread.interrupt();
    }
}

从运行结果来看，调用interrupt方法并没有停止线程。

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

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

1.7.3 能停止的线程-异常法

public class MyThread extends Thread{
    @Override
    public void run() {
        super.run();
        for (int i =0; i <500000; i++) {
            if (this.isInterrupted()) {
                System.out.println("停止状态 退出");
                break;
            }
            System.out.println("i=" + i);
        }
    }
}

public class Run{
    public static void main(String[] args) {
        try {
            MyThread thread =new MyThread();
            thread.start();
            Thread.sleep(2000);
            thread.interrupt();
        } catch (Exception e) {
            System.out.println("main catch");
            e.printStackTrace();
        }
        System.out.println("end");
    }
}

i=408980
i=408981
i=408982
i=408983
i=408984
end
停止状态 退出

上面示例代码虽然停止了线程但如果for下面还有语句，还是会运行的，该如何解决语句继续运行的问题呢 ？

public class MyThread extends Thread{
    @Override
    public void run() {
        super.run();
        try {
            for (int i =0; i <500000; i++) {
                if (this.isInterrupted()) {
                    System.out.println("停止状态 退出");
                    throw new InterruptedException();
                }
                System.out.println("i=" + i);
            }
            System.out.println("for之后运行，线程并未停止");
        } catch (Exception e) {
            System.out.println("MyThread catch");
            e.printStackTrace();
        }
    }
}

public class Run{
    public static void main(String[] args) {
        try {
            MyThread thread =new MyThread();
            thread.start();
            Thread.sleep(2000);
            thread.interrupt();
        } catch (Exception e) {
            System.out.println("main catch");
            e.printStackTrace();
        }
        System.out.println("end");
    }
}

i=410919
i=410920
i=410921
end
停止状态 退出
MyThread catch
java.lang.InterruptedException

1.7.4 在沉睡中停止

如果线程在sleep状态下停止线程，会是什么效果呢？

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

public class Run{
    public static void main(String[] args) {
        try {
            MyThread thread =new MyThread();
            thread.start();
            Thread.sleep(200);
            thread.interrupt();
        } catch (Exception e) {
            System.out.println("main catch");
            e.printStackTrace();
        }
        System.out.println("end");
    }
}

run begin
end
在沉睡中被停止！进入catch!false
java.lang.InterruptedException: sleep interrupted

在sleep状态下，停止某一线程，会进入catch语句，并清除停止状态值，使之变成false。

1.7.5 能停止的线程-暴力停止

使用stop方法停止线程则是非常暴力的。

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 (Exception e) {
            e.printStackTrace();
        }
    }
}

public class Run{
    public static void main(String[] args) {
        try {
            MyThread thread =new MyThread();
            thread.start();
            Thread.sleep(8000);
            thread.stop();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

i=1
i=2
i=3
i=4
i=5
i=6
i=7
i=8
i=9

1.7.6 stop()与java.lang.ThreadDeath异常

调用stop()时会抛出java.lang.ThreadDeath异常。该方法已经被作废，因为如果强制让线程停止则有可能使一些清理性的工作得不到完成。另外一个情况就是对锁定的对象进行了解锁，导致数据得不到同步的处理，出现数据不一致的问题。

1.7.7 释放锁的不良后果

使用stop()释放锁将会给数据造成不一致性的结果。如果出现这样的情况，程序处理的数据就有可能遭到破坏，最终导致程序执行流程错误，一定要特别注意。

public class SynchronizedObject{
    private String userName ="a";
    private String password ="a";
    public String get UserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public void printString(String userName, String password) {
        try {
            this.userName = userName;
            Thread.sleep(100000);
            this.password = password;
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class MyThread extends Thread{
    private SynchronizedObject syncObject;
    public MyThread(SynchronizedObject syncObject) {
        this.syncObject = syncObject;
    }
    @Override
    public void run() {
        syncObject.printString("b", "bbb");
    }
}

public class Run{
    public static void main(String[] args) {
        try {
            SynchronizedObject syncObject =new SynchronizedObject();
            MyThread thread =new MyThread(syncObject);
            thread.start();
            Thread.sleep(8000);
            thread.stop();
            System.out.println(syncObject.getUserName() +"  " +syncObject.getPassword());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

b a

1.7.8 使用return停止线程

interrupt与return结合使用也能实现停止线程的效果。

public class MyThread extends Thread{
    @Override
    public void run() {
        while (true) {
            if (this.isInterrupted()) {
                System.out.println("stop");
                return;
            }
            System.out.println("current time=" + System.currentTimeMillis());
        }
    }
}

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

current time=1587436071260
current time=1587436071260
stop

不过还是建议使用抛异常的方法来实现线程的停止，因为在catch块中还可以讲一场向上抛，是线程停止的时间得以传播。

1.8 暂停线程

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

1.8.1 suispend与resume方法的使用

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++;
        }
    }
}

public class Run{
    public static void main(String[] args) {
        try {
            MyThread thread =new MyThread();
            thread.start();
            Thread.sleep(5000);
            // 暂停线程
            thread.suspend();
            System.out.println("A=" + System.currentTimeMillis() +" i=" + thread.getI());
            Thread.sleep(5000);
            System.out.println("A=" + System.currentTimeMillis() +" i=" + thread.getI());
            // 恢复
            thread.resume();
            Thread.sleep(5000);
            // 继续暂停
            thread.suspend();
            System.out.println("B=" + System.currentTimeMillis() +" i=" + thread.getI());
            Thread.sleep(5000);
            System.out.println("B=" + System.currentTimeMillis() +" i=" + thread.getI());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}


A=1587436765560 i=2885201074
A=1587436770560 i=2885201074
B=1587436775560 i=5820785533
B=1587436780560 i=5820785533

1.8.2 suspend与resume方法的缺点-独占

在使用suspend与resume方法时，如果使用不当，极易造成公共的同步对象的独占，是其他线程无法访问公共同步对象。

public class SynchronizedObject{
    synchronized public void printString() {
        System.out.println("begin");
        if (Thread.currentThread().getName().equals("a")) {
            System.out.println("a线程一直suspend···");
            Thread.currentThread().suspend();
        }
        System.out.println("end");
    }
}

public class Run{
    public static void main(String[] args) {
        try {
            final SynchronizedObject syncObject =new SynchronizedObject();
            Thread thread =new Thread(new Runnable(){
                @Override
                public void run() {
                    syncObject.printString();
                }
            });
            thread.setName("a");
            thread.start();
            Thread.sleep(1000);
            Thread thread2 =new Thread(new Runnable(){
                @Override
                public void run() {
                    System.out.println("thread2 begin");
                    syncObject.printString();
                }
            });
            thread2.start();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

begin
a线程一直suspend···
thread2 begin

还有另外一种独占锁的情况也要格外注意，稍有不慎就会进坑。

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++;
            System.out.println(i);
        }
    }
}

public class Run{
    public static void main(String[] args) {
        try {
            MyThread myThread =new MyThread();
            myThread.start();
            Thread.sleep(1000);
            myThread.suspend();
            System.out.println("main end");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

程序不会再打印“main end”，因为当程序运行到println()方法停止时，同步锁未释放。println()源码如下：

public void println(String x) {
    synchronized (this) {
        print(x);
        newLine();
    }
}

1.8.3 suspend与resume方法的缺点-不同步

在使用suspend与resume方法是容易出现因线程暂停而导致数据不同步的情况。

public class MyObject{
    private String userName ="1";
    private String password ="11";
    public void setValue(String userName, String password) {
        this.userName = userName;
        if ("a".equals(Thread.currentThread().getName())) {
            System.out.println("线程a暂停");
            Thread.currentThread().suspend();
        }
        this.password = password;
    }

    public void print() {
        System.out.println(userName +"  " +password);
    }
}

public class Run{
    public static void main(String[] args) throws InterruptedException{
        final MyObject myObject =new MyObject();
        Thread thread =new Thread(new Runnable(){
            @Override
            public void run() {
                myObject.setValue("lala", "lalala");
            }
        });
        thread.setName("a");
        thread.start();
        Thread.sleep(1000);
        new Thread(new Runnable(){
            @Override
            public void run() {
                myObject.print();
            }
        }).start();
    }
}

线程a暂停
lala  11

1.9 yield方法

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

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

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

用时：19毫秒！

取消Thread.yield();注释，再次运行结果如下所示：

用时：11723毫秒！

1.10 线程的优先级

操作系统中，线程和一划分优先级，优先级较高的线程得到的CPU资源较多，也就是CPU有限制性优先级较高的线程对象中的任务。设置线程优先级有助于帮线程规划器确定下一次选择哪一个线程来优先执行。设置线程优先级使用setPriority()，源码如下：

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

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

JDK中使用三个常量来预定义优先级的值，代码如下：

/**
* The minimum priority that a thread can have.
*/
public final static int MIN_PRIORITY =1;
/**
* The default priority that is assigned to a thread.
*/
public final static int NORM_PRIORITY =5;
/**
* The maximum priority that a thread can have.
*/
public final static int MAX_PRIORITY =10;

1.10.1 线程优先级的继承特性

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

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

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

public class Run{
    public static void main(String[] args)  {
        System.out.println("main thread begin priority="+Thread.currentThread().getPriority());
        Thread.currentThread().setPriority(6);
        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=6
myThread1 run priority=6
myThread2 run priority=6

1.10.2 优先级具有规则性

public class MyThread1 extends Thread{
    @Override
    public void run() {
        long beginTime = System.currentTimeMillis();
        for (int i =0; i <100; i++) {
            Random random =new Random();
            random.nextInt();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("★★★★★ thread1 use time=" +(endTime - beginTime));
    }
}

public class MyThread2 extends Thread{
    @Override
    public void run() {
        long beginTime = System.currentTimeMillis();
        for (int i =0; i <100; i++) {
            Random random =new Random();
            random.nextInt();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("☆☆☆☆☆ thread2 use time=" +(endTime - beginTime));
    }
}

public class Run{
    public static void main(String[] args) {
        for (int i =0; i <5; i++) {
            MyThread1 thread1 =new MyThread1();
            thread1.start();
            MyThread2 thread2 =new MyThread2();
            thread2.setPriority(6);
            thread2.start();
        }
    }
}

第一次执行结果：

☆☆☆☆☆ thread2 use time=0
★★★★★ thread1 use time=0
★★★★★ thread1 use time=0
☆☆☆☆☆ thread2 use time=0
☆☆☆☆☆ thread2 use time=0
★★★★★ thread1 use time=0
☆☆☆☆☆ thread2 use time=0
★★★★★ thread1 use time=4
★★★★★ thread1 use time=3
☆☆☆☆☆ thread2 use time=4

第二次执行结果：

★★★★★ thread1 use time=0
★★★★★ thread1 use time=0
★★★★★ thread1 use time=1
★★★★★ thread1 use time=0
☆☆☆☆☆ thread2 use time=0
★★★★★ thread1 use time=2
☆☆☆☆☆ thread2 use time=1
☆☆☆☆☆ thread2 use time=0
☆☆☆☆☆ thread2 use time=0
☆☆☆☆☆ thread2 use time=0

根据以上时长可以得出，不要把线程的优先级与运行结果的顺序作为衡量的标准，优先级较高的线程不一定每次都先执行完run()方法中的任务。他们的关系具有不确定性和随机性。

1.11 守护线程

Java中有两种线程，一种是用户线程，一种是守护线程。
当进程中不存在费守护线程了，则守护线程自动销毁。典型的守护线程就是GC(垃圾回收器)。任何一个守护线程都是整个JVM中所有费守护线程的“保姆”，只要当前JVM实例中存在任何一个非守护线程没有结束，守护线程就在工作，当最后一个非守护线程结束时，守护线程才随着JVM一同结束工作。

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

public class Run{
    public static void main(String[] args) {
        try {
            MyThread myThread =new MyThread();
            myThread.setDaemon(true);
            myThread.start();
            Thread.sleep(5000);
            System.out.println("main thread end, myThread end");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

参考文献

《Java多线程编程核心技术》高红岩

人生逆旅我亦行人
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
相见恨晚的编程学习词典！谁还不是南极滑冰的那个崽儿？！
weixin_45981643的博客
10-01 6091
received: 审查，复习，回顾，评论 de facto standard: 约定成俗的 spot: 地点，部位，场所，斑点，污点，点；太阳黑子；局部，地区；亮点；现货 linguistic: 语言学 AI - Platform : 人工智能平台 launch: 发布 launchpad: 控制台 canonical: 权威的，经典的 disambiguation: 消歧义 context: 语境 tokenize: 标记化 numeral system: 计数系统。使用一组数字符号表示数（number
RT_Thread基础知识学习汇总.TXT
05-17
这个是一份RT-Thread基础知识汇总，如果不想下载也可以参考博客https://blog.csdn.net/yuupengsun/category_9996721.html 也可以参考官网：https://www.rt-thread.org/ 共同学习。勿喷！勿喷！
【经验总结】10年的嵌入式开发老手，到底是如何快速学习和使用RT-Thread的？（文末赠书5本）
一个专注于嵌入式IoT领域的架构师，深耕IoT领域多年，深度掌握IoT领域的相关技术栈，包括但不限于RTOS内核的实现及其移植、硬件驱动移植开发、网络通讯协议开发、编译构建原理及其实现、底层汇编及编译原理、编译优化及代码重构、嵌入式IoT系统的架构设计等。
02-27 1万+
聊一聊学习RT-Thread这个话题
关于学习RTThread的随笔
Dwyer的博客
06-22 1112
认识操作系统 关于单片机的学习是从51到ARM，慢慢的接触到了操作系统，开始也不明白是什么，就跟着原子哥的例程学，也不知道哪个好？开始学UCOS，后来又用学了FreeRTOS，感觉这两个操作系统也差不多，只能跟着教程学，学了感觉自己是懂了，但是也不知道要怎么使用。而且感觉还是裸机更好用，完全体会不到操作系统的好。所以那时候就问自己，然后呢？ 然后呢？ 例程跑一跑，其实完全没有掌握，一个机缘巧合，接触到了RTThread，正好也有个物联网的项目想用这个操作系统，于是就开始学。 开始以为会和UCOS一样，跑一跑
看完这篇文章，还不知道怎么学单片机，来打我！
热门推荐
张巧龙的博客
09-23 1万+
大家好，我是张巧龙，今天给大家分享一篇文章，来自科岩大佬，推荐大家阅读！经常有人问我，嵌入式该怎么入门，怎么学习，怎么精通，怎么成为专家。我前思后想掏心掏肺，花了大概2周的时间，写了这样的...
这篇 Java 基础，我吹不动了
程序员cxuan的个人主页
09-13 1万+
Hey guys，这里是程序员cxuan，欢迎你收看我最新一期的文章，这篇文章我补充了一些关于《Java基础核心总结》的内容，修改了部分错别字和语句不通顺的地方，并且对内部类、泛型等内容进行了一定的补充，并且我在文章有些地方给出了一些链接，这些链接都是我自己写的硬核文章，能够更好的帮助你理解 Java 这门语言，那么废话不多说，下面开始正文。 Java 概述 什么是 Java？ Java 是 Sun Microsystems 于1995 年首次发布的一种编程语言和计算平台。编程语言还比较好理解，那么什么是
Python学习零基础
weixin_60994019的博客
03-21 1263
Python基本用法易上手
【跟我学RISC-V】（二）RISC-V的基础知识学习与汇编练习
最新发布
April_Zhao的博客
05-04 2567
逐指令讲解和实践
夯实Java基础系列9：深入理解Class类和Object类
Java技术江湖
04-30 4740
本文对java的Class类和Object类的概念和原理做了详尽的介绍，并且详细介绍了Object的各种方法，以及这两个类之间的关系。 Class类和Object类是Java中最根本最重要的两个类，理解它们是理解Java面向对象技术的基础，也是学习所有进阶Java技术的基石。 具体代码在我的GitHub中可以找到 https://github.com/h2pl/MyTech 文章首...
和菜鸟一起学linux之bluez学习记录2
东月之神
03-27 1万+
这里主要摘取对于hci，l2cap，sdp和rfcomm的一些应用编程。   关于hci   一、HCI层协议概述   1、HCI Command Packets 详见bluez源码：lib/hci.h /* Link Control */ #define OGF_LINK_CTL 0x01 #define OCF_INQUIRY 0x0001 #d
基础电子中的基于RT-Thread和STM32的数码相框设计方案
10-19
1.引言　近年来，随着数码相机的普及，一种以数码照片的保存、回放和浏览为核心功能的产品，...基于此，本系统设计了基于RT-Thread和STM32的数码相框。　本系统采用STM32为主控芯片，利用源代码开放的嵌入式RT-Threa
详解Java中Thread 和Runnable区别
08-26
详解Java中Thread和Runnable区别 Java中Thread和Runnable是两个不同的概念，它们都是Java中的线程机制，但是它们之间有着本质的区别。 Thread是Java中的一个类，而Runnable是一个接口。Thread类实现了Runnable接口...
threadx-6.0_rel_Rel?_threadx_ARMthreadx_
09-29
4. "threadx-6.0_rel"文件很可能是ThreadX 6.0版本的发行包，包含运行和开发ThreadX所需的各种组件，如源代码、编译工具链、示例项目和用户指南等。 5. 在嵌入式系统开发中，了解并熟练使用RTOS如ThreadX，以及相关...
Thread基础知识点笔记总结
10-18
Thread 基础知识点笔记总结 Thread 是 Java 中最...传统生产者消费者问题可以用 lock 和 condition 一起控制，用 condition 的 await()和 signal()对生产者和消费者进行等待和唤醒，保证生产一个数据消费一个数据。
定时调度Timer与ScheduledExecutorService的使用与源码解析
Stay Hungry,Stay Foolish
07-07 1万+
1.如何实现指定时间执行任务？2.如何实现按指定周期执行任务？3.Timer与ScheduledExecutorService的区别是什么？本文将介绍定时调度Timer与ScheduledExecutorService的使用及源码解析。
一文详解wait与notify
Stay Hungry,Stay Foolish
05-28 1万+
1）使用wait/notify实现线程间的通信。 2）生产者/消费者模式的实现。 3）方法join的使用。 4）ThreadLocal类的使用。
ReentrantLock你了解多少？
Stay Hungry,Stay Foolish
07-03 1万+
ReentrantLock你了解多少？本文将介绍ReentrantLock类的使用，ReentrantReadWriteLock类的使用。
一文详解synchronized与volatile
Stay Hungry,Stay Foolish
04-28 1万+
1）synchronized对象监视器为Object时的使用； 2）synchronized对象监视器为Class时的使用； 3）非线程安全是如何出现的； 4）volatile的主要作用； 5）volatile与synchronized的区别及使用情况。
C#基础学习：泛型、委托、事件与.NET CORE实战
"C#基础学习，涵盖泛型、委托、事件、接口和抽象类、Lambda、LINQ、表达式树、IO、序列化与反序列化、多线程（Thread、ThreadPool、Task、Async/Await）以及设计模式（如单例、工厂模式）。" 在C#编程语言中，基础...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

人生逆旅我亦行人

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值