JavaSE-10笔记【多线程1（+2024新）】

已于 2024-04-03 15:50:59 修改
阅读量1.1k 收藏 10
点赞数 19
分类专栏： 笔记 Java 文章标签： 笔记 java
于 2024-04-03 15:45:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45041745/article/details/136983631
版权
笔记 同时被 2 个专栏收录
28 篇文章 7 订阅
订阅专栏
Java
23 篇文章 1 订阅
订阅专栏

文章目录


重点掌握：线程安全和线程通信。

1.进程与线程

  • 进程是指操作系统中的一段程序，它是一个正在执行中的程序实例，具有独立的内存空间和系统资源，如文件、网络端口等。在计算机程序执行时，先创建进程，再在进程中进行程序的执行。一般来说，一个进程可以包含多个线程。
  • 线程是指进程中的一个执行单元，是进程的一部分，它负责在进程中执行程序代码。每个线程都有自己的栈和程序计数器，并且可以共享进程的资源。多个线程可以在同一时刻执行不同的操作，从而提高了程序的执行效率。
  • 现代的操作系统是支持多进程的，也就是可以启动多个软件，一个软件就是一个进程。称为：多进程并发。而通常一个进程都是可以启动多个线程的。称为：多线程并发。
  • 多线程的作用：提高处理效率。（多线程的优点之一是能够使 CPU 在处理一个任务时同时处理多个线程，这样可以充分利用 CPU 的资源，提高 CPU 的利用效率。）
  • JVM规范中规定：堆内存、方法区 是线程共享的。虚拟机栈、本地方法栈、程序计数器 是每个线程私有的。
  • 关于Java程序的运行原理
    ①“java HelloWorld”执行后，会启动JVM，JVM的启动表示一个进程启动了。
    ②JVM进程会首先启动一个主线程（main-thread），主线程负责调用main方法。因此main方法是在主线程中运行的。
    ③除了主线程之外，还启动了一个垃圾回收线程。因此启动JVM，至少启动了两个线程。
    ④在main方法的执行过程中，程序员可以手动创建其他线程对象并启动。

在这里插入图片描述

2.并发与并行

  1. 并发（concurrency）

使用单核CPU的时候，同一时刻只能有一条指令执行，但多个指令被快速的轮换执行，使得在宏观上具有多个指令同时执行的效果，但在微观上并不是同时执行的，只是把时间分成若干端，使多个指令快速交替的执行。
在这里插入图片描述
如上图所示，假设只有一个CPU资源，线程之间要竞争得到执行机会。图中的第一个阶段，在A执行的过程中，B、C不会执行，因为这段时间内这个CPU资源被A竞争到了，同理，第二阶段只有B在执行，第三阶段只有C在执行。其实，并发过程中，A、B、C并不是同时进行的（微观角度），但又是同时进行的（宏观角度）。
在同一个时间点上，一个CPU只能支持一个线程在执行。因为CPU运行的速度很快，CPU使用抢占式调度模式在多个线程间进行着高速的切换，因此我们看起来的感觉就像是多线程一样，也就是看上去就是在同一时刻运行。

  1. 并行（parallellism）
    使用多核CPU的时候，同一时刻，有多条指令在多个CPU上同时执行。
    在这里插入图片描述
    如图所示，在同一时刻，ABC都是同时执行（微观、宏观）。

  2. 并发编程与并行编程
    ① 在CPU比较繁忙（假设为单核CPU），如果开启了很多个线程，则只能为一个线程分配仅有的CPU资源，这些线程就会为自己尽量多抢时间片，这就是通过多线程实现并发，线程之间会竞争CPU资源争取执行机会。
    ② 在CPU资源比较充足的时候，一个进程内的多个线程，可以被分配到不同的CPU资源，这就是通过多线程实现并行。
    ③ 至于多线程实现的是并发还是并行？上面所说，所写多线程可能被分配到一个CPU内核中执行，也可能被分配到不同CPU执行，分配过程是操作系统所为，不可人为控制。所以，如果有人问所写的多线程程序是并发还是并行的？答案其实是都有可能。

总结： 单核CPU上的多线程，只是由操作系统来完成多任务间对CPU的运行切换，并非真正意义上的并发。随着多核CPU的出现，也就意味着不同的线程能被不同的CPU核得到真正意义的并行执行，故而多线程技术得到广泛应用。
不管并发还是并行，都提高了程序对CPU资源的利用率，最大限度地利用CPU资源，而我们使用多线程的目的就是为了提高CPU资源的利用率。

3.线程的调度模型

如果多个线程被分配到一个CPU内核中执行，则同一时刻只能允许有一个线程能获得CPU的执行权，那么进程中的多个线程就会抢夺CPU的执行权，这就是涉及到线程调度策略。
两种调度策略：

  • 分时调度模型
    所有线程轮流使用CPU的执行权，并且平均的分配每个线程占用的CPU的时间。
  • 抢占式调度模型
    让优先级高的线程以较大的概率优先获得CPU的执行权，如果线程的优先级相同，那么就会随机选择一个线程获得CPU的执行权，而Java采用的就是抢占式调用。

4.实现线程

4.1 第一种方式：继承Thread

①编写一个类继承Thread，重写run方法。
②创建线程对象：Thread t = new MyThread();
③启动线程：t.start();

示例代码：

package threadtest;

/**
 * 在java语言中，实现线程有两种方式，第一种方式：
 * 第一步：编写一个类继承java.lang.Thread
 * 第二步：重写run()方法
 * 第三步：new线程对象
 * 第四步：调用线程对象的start()方法来启动线程
 */
public class ThreadTest01 {
    public static void main(String[] args) {
        //创建线程对象
        Thread t = new MyThread();

        //直接调用run()方法，不会启动新的线程
        //java中有一个语法规则：对于方法体重的代码，必须遵循自上而下的顺序逐次执行
        //run()方法不结束，main方法是无法继续执行的
        //t.run();
        
        //调用start()方法，启动线程
        //java中有一个语法规则：对于方法体中的代码，必须遵循自上而下的顺序逐次执行
        //start()方法不结束，main方法是无法继续执行的
        //start()方法瞬间就会结束，因为这个方法的作用是启动一个新的线程，只要新线程启动成功了，start()就结束了
        t.start();

        //下面的代码在main方法中，因此其属于在主线程中
        for (int i = 0; i < 100; i++) {
            System.out.println("main-->" + i);
        }
    }
}

/**
 * 自定义一个线程类
 * java.lang.Thread本身就是一个线程。
 * MyThread继承Thread，因此MyThread本身也是一个线程。
 */
class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("Thread-->" + i);
        }
    }
}

运行结果：

Thread-->0
Thread-->1
Thread-->2
Thread-->3
Thread-->4
Thread-->5
Thread-->6
Thread-->7
Thread-->8
Thread-->9
Thread-->10
Thread-->11
Thread-->12
main-->0
main-->1
main-->2
main-->3
main-->4
main-->5
main-->6
main-->7
main-->8
main-->9
main-->10
main-->11
Thread-->13
main-->12
main-->13
main-->14
main-->15
main-->16
main-->17
main-->18
main-->19
main-->20
main-->21
main-->22
main-->23
main-->24
main-->25
Thread-->14
Thread-->15
Thread-->16
Thread-->17
Thread-->18
Thread-->19
Thread-->20
main-->26
Thread-->21
Thread-->22
Thread-->23
Thread-->24
Thread-->25
Thread-->26
Thread-->27
Thread-->28
Thread-->29
Thread-->30
Thread-->31
Thread-->32
Thread-->33
Thread-->34
Thread-->35
Thread-->36
Thread-->37
Thread-->38
Thread-->39
Thread-->40
Thread-->41
Thread-->42
Thread-->43
Thread-->44
Thread-->45
Thread-->46
Thread-->47
Thread-->48
Thread-->49
Thread-->50
Thread-->51
Thread-->52
Thread-->53
Thread-->54
Thread-->55
Thread-->56
Thread-->57
Thread-->58
Thread-->59
main-->27
Thread-->60
Thread-->61
Thread-->62
Thread-->63
Thread-->64
Thread-->65
Thread-->66
Thread-->67
main-->28
main-->29
main-->30
main-->31
main-->32
main-->33
main-->34
main-->35
main-->36
main-->37
main-->38
main-->39
main-->40
main-->41
main-->42
main-->43
Thread-->68
Thread-->69
Thread-->70
Thread-->71
Thread-->72
Thread-->73
Thread-->74
main-->44
Thread-->75
Thread-->76
Thread-->77
Thread-->78
Thread-->79
Thread-->80
main-->45
main-->46
Thread-->81
Thread-->82
Thread-->83
Thread-->84
Thread-->85
Thread-->86
Thread-->87
Thread-->88
Thread-->89
Thread-->90
main-->47
main-->48
Thread-->91
Thread-->92
Thread-->93
Thread-->94
main-->49
Thread-->95
Thread-->96
Thread-->97
Thread-->98
Thread-->99
main-->50
main-->51
main-->52
main-->53
main-->54
main-->55
main-->56
main-->57
main-->58
main-->59
main-->60
main-->61
main-->62
main-->63
main-->64
main-->65
main-->66
main-->67
main-->68
main-->69
main-->70
main-->71
main-->72
main-->73
main-->74
main-->75
main-->76
main-->77
main-->78
main-->79
main-->80
main-->81
main-->82
main-->83
main-->84
main-->85
main-->86
main-->87
main-->88
main-->89
main-->90
main-->91
main-->92
main-->93
main-->94
main-->95
main-->96
main-->97
main-->98
main-->99

Process finished with exit code 0

直接调用run()方法的内存结构图：
在这里插入图片描述

调用start()方法的内存结构图：
在这里插入图片描述

4.2 第二种方式：实现Runnable接口

①编写一个类实现Runnable接口，实现run方法。
②创建线程对象：Thread t = new Thread(new MyRunnable());
③启动线程：t.start();

示例代码：

package threadtest;

/**
 * 在java语言中，实现线程有两种方式，第二种方式：
 * 第一步：编写一个类实现java.lang.Runnable接口（可运行接口）
 * 第二步：实现接口中的run方法
 * 第三步：new线程对象
 * 第四步：调用线程的start方法启动线程
 */
public class ThreadTest02 {
    public static void main(String[] args) {
        //创建Runnable对象
        Runnable r = new MyRunnable();

        //创建线程对象
        Thread t = new Thread(r);

        //启动线程
        t.start();

        for (int i = 0; i < 100; i++) {
            System.out.println("main-->" + i);
        }
    }
}

/**
 * 创建一个类实现Runnable接口
 */
class MyRunnable implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("Thread-->" + i);
        }
    }
}

运行结果：

main-->0
Thread-->0
Thread-->1
Thread-->2
Thread-->3
Thread-->4
Thread-->5
Thread-->6
Thread-->7
Thread-->8
Thread-->9
Thread-->10
Thread-->11
Thread-->12
Thread-->13
main-->1
main-->2
Thread-->14
Thread-->15
Thread-->16
Thread-->17
Thread-->18
Thread-->19
Thread-->20
Thread-->21
Thread-->22
Thread-->23
main-->3
main-->4
main-->5
main-->6
main-->7
main-->8
main-->9
main-->10
main-->11
main-->12
main-->13
main-->14
main-->15
main-->16
main-->17
main-->18
Thread-->24
Thread-->25
Thread-->26
Thread-->27
Thread-->28
Thread-->29
Thread-->30
Thread-->31
Thread-->32
Thread-->33
Thread-->34
Thread-->35
Thread-->36
Thread-->37
Thread-->38
Thread-->39
Thread-->40
Thread-->41
Thread-->42
Thread-->43
Thread-->44
Thread-->45
Thread-->46
Thread-->47
Thread-->48
Thread-->49
Thread-->50
Thread-->51
Thread-->52
Thread-->53
Thread-->54
Thread-->55
Thread-->56
Thread-->57
Thread-->58
Thread-->59
Thread-->60
Thread-->61
Thread-->62
Thread-->63
Thread-->64
Thread-->65
main-->19
main-->20
Thread-->66
Thread-->67
Thread-->68
Thread-->69
Thread-->70
Thread-->71
Thread-->72
Thread-->73
Thread-->74
Thread-->75
Thread-->76
Thread-->77
Thread-->78
Thread-->79
Thread-->80
Thread-->81
Thread-->82
Thread-->83
Thread-->84
Thread-->85
Thread-->86
Thread-->87
Thread-->88
Thread-->89
Thread-->90
Thread-->91
Thread-->92
Thread-->93
Thread-->94
Thread-->95
Thread-->96
Thread-->97
Thread-->98
Thread-->99
main-->21
main-->22
main-->23
main-->24
main-->25
main-->26
main-->27
main-->28
main-->29
main-->30
main-->31
main-->32
main-->33
main-->34
main-->35
main-->36
main-->37
main-->38
main-->39
main-->40
main-->41
main-->42
main-->43
main-->44
main-->45
main-->46
main-->47
main-->48
main-->49
main-->50
main-->51
main-->52
main-->53
main-->54
main-->55
main-->56
main-->57
main-->58
main-->59
main-->60
main-->61
main-->62
main-->63
main-->64
main-->65
main-->66
main-->67
main-->68
main-->69
main-->70
main-->71
main-->72
main-->73
main-->74
main-->75
main-->76
main-->77
main-->78
main-->79
main-->80
main-->81
main-->82
main-->83
main-->84
main-->85
main-->86
main-->87
main-->88
main-->89
main-->90
main-->91
main-->92
main-->93
main-->94
main-->95
main-->96
main-->97
main-->98
main-->99

Process finished with exit code 0

总结：
优先选择第二种方式：因为实现接口的同时，保留了类的继承。
第二种方式也可以使用匿名内部类如下：

Thread t = new Thread(new Runnable() {
  @Override
       public void run() {
           for (int i = 0; i < 100; i++) {
               System.out.println("main-->" + i);
           }  
       }
   });
t.start();

4.3 t.start()和t.run()的本质区别？

本质上没有区别，都是普通方法调用。只不过两个方法完成的任务不同。

  • t.run()是调用run方法。执行run方法中的业务代码。
  • t.start()是启动线程，只要线程启动了，start()方法就执行结束了。

4.4 线程常用的三个方法

实例方法：
①String getName(); 获取线程对象的名字；
②void setName(String name);修改线程对象的名字。
静态方法：
①static Thread currentThread();获取当前线程对象的引用。

package threadtest;

public class ThreadTest03 {
    public static void main(String[] args) {
        Thread t1 = new MyNewThread();
        t1.start();

        Thread t2 = new MyNewThread();
        t2.start();

        Thread thread = Thread.currentThread();
        System.out.println("当前运行线程：" + thread.getName());

    }
}


class MyNewThread extends Thread{
    @Override
    public void run() {
        //获取当前运行线程的引用
        Thread t = Thread.currentThread();

        //获取当前运行线程的名字
        System.out.println("当前运行线程：" + t.getName()); 
    }
}

运行结果：
在这里插入图片描述
创建线程时，若没有给线程指定名字，则会给对应线程赋上默认的名字：Thread-xx。
可以修改线程名字：

package threadtest;

public class ThreadTest03 {
    public static void main(String[] args) {
        Thread t1 = new MyNewThread();
        t1.setName("t1");
        t1.start();

        Thread t2 = new MyNewThread();
        t2.setName("t2");
        t2.start();

        Thread thread = Thread.currentThread();
        System.out.println("当前运行线程：" + thread.getName());

    }
}


class MyNewThread extends Thread{
    @Override
    public void run() {
        //获取当前运行线程的引用
        Thread t = Thread.currentThread();

        //获取当前运行线程的名字
        System.out.println("当前运行线程：" + t.getName());
    }
}

运行结果:
在这里插入图片描述

也可以在创建线程时，通过构造方法为线程指定名字：

package threadtest;

public class ThreadTest03 {
    public static void main(String[] args) {
        Thread t1 = new MyNewThread("tt1");
//        t1.setName("t1");
        t1.start();

        Thread t2 = new MyNewThread("tt2");
//        t2.setName("t2");
        t2.start();

        Thread thread = Thread.currentThread();
        System.out.println("当前运行线程：" + thread.getName());

    }
}


class MyNewThread extends Thread{
    public MyNewThread() {
    }

	//有参构造方法
    public MyNewThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        //获取当前运行线程的引用
        Thread t = Thread.currentThread();

        //获取当前运行线程的名字
        System.out.println("当前运行线程：" + t.getName());
    }
}

运行结果：
在这里插入图片描述

5.线程的生命周期（把生命周期图背会）

线程的生命周期有7个状态：

  1. 新建状态；
  2. 就绪状态；
  3. 运行状态
  4. 超时等待状态；
  5. 等待状态（wait()方法）；
  6. 阻塞状态（线程同步机制）；
  7. 终止状态。
    在这里插入图片描述

5.1 Thread.sleep()方法

static void sleep(long millis)：静态方法，没有返回值，参数是为毫秒单位的时间，1秒=1000毫秒。
作用：让当前线程进入休眠，即让当前线程放弃占有的CPU时间片，使其进入超时等待状态。等待时间以设定的毫秒数为准，在该指定的时间范围内，当前线程没有权利抢夺CPU时间片。
如何理解“当前线程”：Thread.sleep(1000)，这个代码出现在哪个线程中，这个线程就是“当前线程”。

示例代码：

package threadtest;

public class ThreadTest04 {
    public static void main(String[] args) {
        //让主线程睡眠5秒
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + "====>" + i);
        }

        Runnable r = new MyNewRunnable();
        Thread t = new Thread(r);
        t.start();

    }


}

class MyNewRunnable implements Runnable{

    //run方法在重写时不能在方法声明位置使用 throws 抛出异常，子类不能比父类抛出更多异常，所以这里只能try...catch
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "====>" + i);
            //让当前线程睡眠1秒再进入下一次循环
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

5.1.1 关于Thread.sleep()的面试题

package threadtest;

public class ThreadTest05 {
    public static void main(String[] args) {
        MyLatestThread t = new MyLatestThread();
        t.setName("t");
        t.start();

        try {
            t.sleep(3000);  //当前代码是让t线程睡眠3秒吗？
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "====>" + i);
        }
    }
}


class MyLatestThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "====>" + i);
        }
    }
}

以上t.sleep(3000);并不是让t线程睡眠，而是让当前线程，即主线程main线程睡眠。

5.2 如何中断一个线程的睡眠

语法：线程对象.interrupt(true);
示例代码：

package threadtest.thread06;

public class ThreadTest06 {
    public static void main(String[] args) {
        //创建线程
        Thread t = new MyThread();
        t.setName("t");

        //启动线程
        t.start();

        //要求5秒之后睡眠的t线程起来干活
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //终止t线程的睡眠
        //其底层原理是利用了异常处理机制：当调用这个方法时，如果t线程正在睡眠，必然会抛出：InterruptedException，然后捕捉异常，终止睡眠
        t.interrupt();
    }
}

class MyThread extends Thread{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "--> begin");
        try {
            //睡眠一年
            Thread.sleep(1000*60*60*24*365);
        } catch (InterruptedException e) {
            System.out.println("睡眠中断了！");
            e.printStackTrace();

        }
        //睡眠一年之后，起来干活了
        System.out.println(Thread.currentThread().getName() + " --> work!");

    }
}

运行结果：
在这里插入图片描述

5.3 如何强行终止一个线程

5.3.1 已过时的方式

语法：线程对象.stop();
如下代码：

package threadtest.thread07;

public class ThreadTest07 {
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable());
        t.setName("t");
        t.start();

        //当前线程睡眠5秒
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //终止t线程的执行，从java2开始就不建议使用了，因为这种方式是强行终止线程，容易导致数据丢失。
        t.stop();
    }
}

class MyRunnable implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "-->" + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }
}

运行结果：
在这里插入图片描述

5.3.2 推荐的方式

设置标记。
如下代码：

package threadtest.thread08;

public class ThreadTest08 {
    public static void main(String[] args) {
        MyRunnable r = new MyRunnable();
        Thread t = new Thread(r);
        t.setName("t");
        t.start();

        //当前线程睡眠5秒
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //修改标记，终止线程t的执行
        r.ifRun = false;
    }
}

class MyRunnable implements Runnable{
    //设置标记
    boolean  ifRun = true;
    @Override
    public void run() {

        for (int i = 0; i < 10; i++) {
            if(ifRun){
                System.out.println(Thread.currentThread().getName() + "-->" + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }else{
                return;
            }
        }
    }
}

运行结果：
在这里插入图片描述

5.4 守护线程

在java语言中，线程被分为两大类：

  1. 用户线程（非守护线程）【上面例子中定义的线程，包括主线程，都是用户线程】；
  2. 守护线程（后台线程）。

在JVM中有一个隐藏的守护线程：GC线程。
守护线程的特点：所有用户线程结束之后，守护线程自动退出/结束。

设置一个线程为守护线程（需要在线程启动前设置）：线程对象.setDaemon(true);

示例代码：

package threadtest.thread09;

public class ThreadTest09 {
    public static void main(String[] args) {
        Thread t = new MyThread();
        t.setName("t");

        //需要再t线程启动前，设置t线程为守护线程，所有用户线程结束守护线程自动结束
        t.setDaemon(true);

        //启动t线程
        t.start();

        //设置main用户线程10秒后结束
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "-->" + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }   
    }
}


class MyThread extends Thread{
    @Override
    public void run() {
        int i = 0;
        //死循环
        while (true){
            System.out.println(Thread.currentThread().getName() + " --> " + (++i));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

运行结果：
在这里插入图片描述

5.5 定时器

JDK中提供的定时任务：

  • java.util.Timer：定时器
  • java.util.TimerTask：定时任务
    定时器+定时任务可以帮我们在程序中完成：指定时间开始，每间隔多久执行一次某段程序。

Timer的构造方法：

  • Timer();
  • Timer(boolean isDaemon): isDaemon为true表示该定时器是一个守护线程。

Timer的一个方法：

  • schedule(TimerTask task, Date firstTime, long period)：task为需要执行的任务，firstTime为第一次执行时间，period为每隔多久执行一次（单位：毫秒）。
package threadtest.thread10;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.TimerTask;

/**
 * 定时任务类TimerTask是一个抽象类，其实现了Runnable接口，所以继承该类需要覆写run()方法
 */
public class LogTimerTask extends TimerTask {

    int i = 1;
    SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");

    @Override
    public void run() {
        Date now = new Date();
        String strTime = dateFormat.format(now);
        System.out.println(strTime + " " + (i++));
    }
}

package threadtest.thread10;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;

public class ThreadTest10 {
    public static void main(String[] args) throws Exception {
        //创建定时器对象（其本质上就是一个线程）
        //如果这个定时器执行的任务是一个后台任务，建议将其定义为守护线程
        Timer timer = new Timer(true);

        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date firstTime = dateFormat.parse("2024-03-26 17:45:00");

        //指定定时任务为LogTimerTask，第一次执行时间为firstTime，每间隔1秒执行一次。
        timer.schedule(new LogTimerTask(), firstTime,1000);


        //main线程5秒后结束，则上述守护线程也随之结束
        for (int i = 0; i < 5; i++) {
            Thread.sleep(1000);
        }
    }
}

运行结果：
在这里插入图片描述

5.6 线程合并

join()方法是一个实例方法，线程对象调用join()方法完成线程合并。

Thread t = new Thread();
t.setName("t");
t.join();

t.join方法其实是让当前线程进入阻塞状态，直到t线程结束，当前线程阻塞解除。
假设在main方法（main线程）中调用了t.join()方法，则为将t线程合并到main线程中，main线程进入阻塞状态，直到t线程执行结束，main线程解除阻塞。

join()方法和sleep()方法的联系和区别：

  1. sleep()方法和join()方法都是让当前线程进入阻塞状态（超时等待状态因也可以看作是一种阻塞状态）；
  2. sleep()方法是静态方法，而join()方法是实例方法；
  3. sleep()方法可以指定睡眠的时长，而join()方法不能保证阻塞的时长；
  4. sleep()方法的阻塞解除条件：设置的时间过去了；join()方法的阻塞解除条件：调用join()方法的那个线程结束了。

示例代码：

package threadtest.thread11;

public class ThreadTest11 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new MyThread();
        t.setName("t");
        t.start();

        //合并线程，将t线程合并到main线程中，main线程收到阻塞，t线程继续执行，直到t线程结束，main线程阻塞解除
        t.join();
        System.out.println("main begin");
        //主线程
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName() + "-->" + i);
        }
        System.out.println("main over");
    }
}

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

运行结果：

t-->0
t-->1
t-->2
t-->3
t-->4
t-->5
t-->6
t-->7
t-->8
t-->9
t-->10
t-->11
t-->12
t-->13
t-->14
t-->15
t-->16
t-->17
t-->18
t-->19
main begin
main-->0
main-->1
main-->2
main-->3
main-->4
main-->5
main-->6
main-->7
main-->8
main-->9
main-->10
main-->11
main-->12
main-->13
main-->14
main-->15
main-->16
main-->17
main-->18
main-->19
main over

Process finished with exit code 0

join()方法也可以有参数，参数是毫秒，表示线程合并时长。

package threadtest.thread11;

public class ThreadTest11 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new MyThread();
        t.setName("t");
        t.start();

        //合并线程，将t线程合并到main线程中，main线程受到阻塞，t线程继续执行，直到t线程结束，main线程阻塞解除
        //合并时长为10毫秒，即只阻塞当前线程10毫秒，但并不一定能达到设置的阻塞时长，如果在指定的时间内，t线程早就结束了，则阻塞就立即解除了。
        t.join(10);
        System.out.println("main begin");
        //主线程
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName() + "-->" + i);
        }
        System.out.println("main over");

    }
}

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

5.7 线程优先级

线程是可以设置优先级的，JVM采用的是抢占式调度模型，优先级高的线程获取CPU时间片的总体概率会高一些。
默认情况下一个线程的优先级是5，最低为1，最高为10。

package threadtest.thread12;

public class ThreadTest12 {
    public static void main(String[] args) {
        System.out.println("最低优先级" + Thread.MIN_PRIORITY);
        System.out.println("最高优先级" + Thread.MAX_PRIORITY);
        System.out.println("默认优先级" + Thread.NORM_PRIORITY);

        //获取线程的优先级
        System.out.println("当前线程优先级：" + Thread.currentThread().getPriority());

        //设置优先级
        Thread.currentThread().setPriority(10);
        System.out.println("当前线程优先级：" + Thread.currentThread().getPriority());
    }
}

运行结果：
在这里插入图片描述
给多个线程设置不同优先级：

package threadtest.thread12;

public class ThreadTest12 {
    public static void main(String[] args) {
        Thread t1 = new MyThread();
        t1.setName("t1");

        Thread t2 = new MyThread();
        t2.setName("t2");

        //设置t1为最高优先级，t2为最低优先级，相对来说t1指定的概率高一些
        t1.setPriority(Thread.MAX_PRIORITY); 
        t2.setPriority(Thread.MIN_PRIORITY);
        
        t1.start();
        t2.start();

    }
}


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

5.8 线程让位

静态方法：Thread.yield()，当前线程让位。
注意：让位不会使当前线程进入阻塞状态，只是放弃目前占有的CPU时间片，进入就绪状态，继续抢夺CPU时间片。
示例代码：

package threadtest.thread13;

/**
 * 线程让位
 */
public class ThreadTest13 {
    public static void main(String[] args) {
        Thread t1 = new MyThread();
        t1.setName("t1");

        Thread t2 = new MyThread();
        t2.setName("t2");

        t1.start();
        t2.start();
    }
}

class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(Thread.currentThread().getName().equals("t1") && i%10 == 0){ //当前线程为t1线程，且i为10的倍数时，进行线程让位
                System.out.println(Thread.currentThread().getName() + "让位了，此时i=" + i);
                //注意：t1线程让位只是放弃当前占有的时间片，至于后续时间片被哪个线程抢占并不一定，也有可能t1会继续抢到
                Thread.yield();
            }
            System.out.println(Thread.currentThread().getName() + "==>" + i);
        }
    }
}

运行结果就不贴了。

ED_Sunny小王
关注
  • 19
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
马士兵多线程笔记.zip
02-21
马士兵多线程训练营上课笔记
JavaSE异常与多线程
06-04
入门级笔记，适合查漏补缺。
JavaSE-11笔记【多线程2（+2024新）】
weixin_45041745的博客
04-03 1047
在静态方法上添加synchronized关键字，实际上是为了保证静态变量的安全；在实例方法上添加synchronized关键字，实际上是为了保证实例变量的安全。
JavaSE-09笔记【异常（+2024新）】
weixin_45041745的博客
03-19 1109
什么是异常？有什么用？Java中的异常是指程序运行时出现了错误或异常情况，导致程序无法继续正常执行的现象。例如，数组下标越界、空指针异常、类型转换异常等都属于异常情况。Java提供了异常处理机制，即在程序中对可能出现的异常情况进行捕捉和处理。异常机制可以帮助程序员更好地管理程序的错误和异常情况，避免程序崩溃或出现不可预测的行为。没有异常机制的话，程序中就可能会出现一些难以调试和预测的异常行为，可能导致程序崩溃，甚至可能造成数据损失或损害用户利益。
JavaSE-07笔记【常用类1（+2024新）】
weixin_45041745的博客
03-12 795
不需要死记硬背，知道有，想得起来用，具体翻阅API帮助文档即可。
JavaSE-12笔记【集合1（+2024新）】
weixin_45041745的博客
04-14 932
什么是集合，有什么用？①集合是一种容器，用来组织和管理数据的。非常重要。②Java的集合框架对应的这套类库其实就是对各种数据结构的实现。③每一个集合类底层采用的数据结构不同，例如ArrayList集合底层采用了数组，LinkedList集合底层采用了双向链表，HashMap集合底层采用了哈希表，TreeMap集合底层采用了红黑树。④我们不用写数据结构的实现了。直接用就行了。但我们需要知道的是在哪种场合下选择哪一个集合效率是最高的。
JavaSE笔记7.3-多线程-多线程的安全问题
qq_38503984的博客
02-16 150
一. 引入 class Ticket implements Runnable { private int num=100; public void run() { while(true) { if(num>0) { try{ ...
JavaSE基础24笔记多线程
欢迎大家互相交流分享
01-28 130
24.01_多线程(多线程的引入)(了解) 1.什么是线程 线程是程序执行的一条路径, 一个进程中可以包含多条线程 多线程并发执行可以提高程序的效率, 可以同时完成多项工作 2.多线程的应用场景 红蜘蛛同时共享屏幕给多个电脑 迅雷开启多条线程一起下载 QQ同时和多个人一起视频 服务器同时处理多个客户端请求 24.02_多线程(多线程并行和并发的区别)(了解) 并行就是两个任务同时...
JavaSE-13笔记【集合2（+2024新）】
最新发布
weixin_45041745的博客
04-14 825
return age;} }Objects;return age;@Override//key中存储自定义类型User Map < User , String > map = new HashMap < User , String >();//创建User对象 User user1 = new User("张三" , 18);User user2 = new User("李四" , 23);
JavaSE学习笔记----多线程
qq_42922249的博客
04-28 416
多线程 定义 多个单一顺序执行的流程并发运行，会造成“感官上的同时运行”的效果。 并发 多个线程实际运行是走走停停的。线程调度程序会将CPU运行时间划分为若干个时间片段并尽可能均匀的分配给每个线程，拿到时间片的线程被CPU执行这段时间。当超时后线程调度程序会再次分配一个时间片段给一个线程使得CPU执行它。如此反复。由于CPU执行时间在纳秒级别，我们感觉不到切换线程运行的过程。所以微观上走走停停，宏观上感觉一起运行的现象成为并发运行! 用途 当出现多个代码片段执行顺序有冲突时，希望它们各干各的时就应
JavaSE笔记7.2-多线程-创建线程
qq_38503984的博客
02-14 116
一. 方法1：继承Java.lang.Thread类 通过对API的查找，Java已经提供了对线程这类事物的描述，就是Java.lang.Thread类.。 1. 步骤 继承Thread类 复写Thread类中的run方法 将自定义的代码存储在run方法，让线程运行 调用线程的start方法 该方法有2个作用：启动线程&调用run方法 class Demo extends ...
JavaSE精华笔记.zip
01-06
Java基础部分笔记，包含IO流、多线程、网络编程、Lambda表达式，适合巩固基础以及新手查看，都是Java基础的精华
javaSE笔记
03-14
JavaSE学习笔记，多线程，I/O流，集合，反射，常用设计模式
java8源码-JavaSE-Code:JavaSE的代码练习与学习笔记总结
06-04
[Java多线程核心编程技术] 书籍笔记 第一章:Java多线程技能 线程是进程中的子任务 interrupted与isInterrupted的区别: interrupted是Thread类的静态方法,里面调用了isTnterrupted方法[currentThread().isInterrupted...
Python安装tensorflow过程中出现“No matching distribution found for tensorflow”的解决办法
热门推荐
weixin_45041745的博客
11-14 1万+
Python安装tensorflow过程中出现“No matching distribution found for tensorflow”的解决办法
【Python】小甲鱼2022最新版课程p20-p26——列表笔记2（课后作业篇）
weixin_45041745的博客
07-28 2097
跟着小甲鱼的python课程做的笔记，自用。
【Python】小甲鱼2022最新版课程p1-p5——基本知识&变量定义&字符串定义笔记
weixin_45041745的博客
07-19 1656
跟着小甲鱼的python课程做的笔记，自用。
【Python】小甲鱼2022最新版课程p6-p12——数字类型及其运算&布尔类型&运算符及其优先级笔记
weixin_45041745的博客
07-21 1551
跟着小甲鱼的python课程做的笔记，自用。
那javaSE -17可不可以用
06-12
JavaSE-17中包含了Java 14及更早版本中的所有功能，同时还引入了新的功能和改进。 因此，如果您想在Java中使用记录特性，建议您升级到最新的JavaSE-17版本。请注意，一些旧版的Java开发工具可能需要更新才能支持...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

ED_Sunny小王

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

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

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

打赏作者

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

抵扣说明：

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

余额充值