线程的控制方法

已于 2022-10-28 12:20:52 修改
阅读量1.9k 收藏 4
点赞数 3
分类专栏： Thread 文章标签： java
于 2021-06-30 11:10:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ChineseSoftware/article/details/118356879
版权

一、Java 中的线程状态转换

【注】不是 start 之后就立刻开始执行，只是就绪了(CPU可能正在运行其他的线程)。只有被 CPU 调度之后，线程才开始执行，当 CPU 分配给的时间片到了，又回到就绪状态，继续排队等候。

二、线程控制的基本方法

在这里插入图片描述

  1. isAlive()：判断线程是否还活着。start 之后，终止之前都是活的。
  2. getPriority()：获得线程的优先级数值。
  3. setPriority()：设置线程的优先级数值(线程是有优先级别的)。
  4. Thread.sleep()：将当前线程睡眠指定毫秒数。
  5. join()：调用某线程的该方法，将当前线程与该线程合并，也即等待该线程结束后，再恢复当前线程的运行状态(比如在线程B中调用了线程A的 join()，直到线程A执行完毕后，才会继续执行线程B)。
  6. yield()：当前线程让出 CPU，进入就绪状态，等待 CPU 的再次调度。
  7. wait()：当前线程进入对象的 wait pool。
  8. notify()/notifyAll()：唤醒对象的 wait pool 中的一个/所有的等待线程。

三、isAlive()：判定线程是否处于活动状态

//判定线程是否处于活动状态：就绪状态、运行状态、阻塞状态
public class Demo2 {
    public static void main(String[] args) {
       new ThreadB().start();
    }
}
class ThreadB extends Thread {
	@Override
	public void run() {
		System.out.println("检测线程是否是活动状态");
		System.out.println(Thread.currentThread().isAlive());
	}
}

四、setPriority()：设置线程的优先级

//设置线程优先级 MAX_PRIORITY：最大为10 
//MIN_PRIORITY：最小为1 
//DEFAULT_PRIORITY：默认为5
public class Demo4 {
	public static void main(String[] args) {
		ThreadD td = new ThreadD();
		ThreadE te = new ThreadE();
		td.start();// 谁先启动，谁抢占资源的概率越大
		te.start();
		td.setPriority(Thread.MAX_PRIORITY);// 设置优先级为最大，10
		te.setPriority(Thread.MIN_PRIORITY);// 设置优先级为最小，1
	}
}
class ThreadD extends Thread {
	@Override
	public void run() {
		// 默认优先级为5
		// System.out.println(Thread.currentThread().getPriority());
		for (int i = 0; i < 5; i++) {
			System.out.println("ThreadD j---" + i);
		}
	}
}
class ThreadE extends Thread {
	@Override
	public void run() {
		for (int i = 0; i < 5; i++) {
			System.out.println("ThreadE i---" + i);
		}
	}
}

ThreadD j---0
ThreadE i---0
ThreadE i---1
ThreadE i---2
ThreadE i---3
ThreadE i---4
ThreadD j---1
ThreadD j---2
ThreadD j---3
ThreadD j---4

五、sleep()：将当前线程睡眠指定毫秒数

  1. 可以调用 Thread 的静态方法：
    public static void sleep(long millis) throws InterruptedException在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)，此操作受到系统计时器和调度程序精度和准确性的影响，该线程不丢失任何监视器的所属权。InterruptedException - 如果任何线程中断了当前线程，当抛出该异常时，当前线程的中断状态被清除。

  2. 由于是静态方法，sleep() 可以由类名直接调用：Thread.sleep(.....);

  3. Thread.Sleep(0)作用：触发操作系统立刻重新进行一次CPU竞争。结果或许是当前线程仍然获得CPU控制权，也许会换成别的线程获得CPU控制权。大循环里面经常写它，以给其他线程比如Paint线程获得CPU控制权的机会，界面就不会假死在那里。

class TestThread {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
        try {                   // 在哪个线程中调用 Sleep，就让哪个线程睡眠
            Thread.sleep(8000); // 主线程睡8秒后，打断子线程
        } catch (InterruptedException e) {
        }
        thread.interrupt();     // 打断子线程
    }
}
class MyThread extends Thread {
    @Override
    public void run() {
        while(true){
            System.out.println("=== "+ new Date()+" ===");
            try {
                sleep(1000); // 每隔一秒打印一次日期
            } catch (InterruptedException e) {
                return;
            }
        }
    }  
}

运行结果：

=== Tue May 09 11:09:43 CST 2017 ===
=== Tue May 09 11:09:44 CST 2017 ===
=== Tue May 09 11:09:45 CST 2017 ===
=== Tue May 09 11:09:46 CST 2017 ===
=== Tue May 09 11:09:47 CST 2017 ===
=== Tue May 09 11:09:48 CST 2017 ===
=== Tue May 09 11:09:49 CST 2017 ===
=== Tue May 09 11:09:50 CST 2017 ===

子线程每隔一秒打印系统日期，主线程睡眠8秒后，打断子线程，子线程结束。此例还可用一种简单、粗暴、好用的方法中断子线程：

class TestThread {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
        try {                    // 在哪个线程中调用 Sleep，就让哪个线程睡眠
            Thread.sleep(5000); // 主线程睡8秒后，打断子线程
        } catch (InterruptedException e) {
        }
        thread.flag = false; // 打断子线程
    }
}
class MyThread extends Thread {
    boolean flag = true;
    @Override
    public void run() {
        while(flag){
            System.out.println("=== "+ new Date()+" ===");
            try {
                sleep(1000); // 每隔一秒打印一次日期
            } catch (InterruptedException e) {
            }
        }
    }
}

运行结果：

=== Tue May 09 12:21:24 CST 2017 ===
=== Tue May 09 12:21:25 CST 2017 ===
=== Tue May 09 12:21:26 CST 2017 ===
=== Tue May 09 12:21:27 CST 2017 ===
=== Tue May 09 12:21:28 CST 2017 ===

六、join()：合并某个线程，相当于方法的调用

class TestThread {
    public static void main(String[] args) {
        MyThread myThread = new MyThread("childThread");
        myThread.start();
        try {
            myThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for(int i = 1; i <= 4; i++){
            System.out.println("I am the mainThread");
        }
    }
}
class MyThread extends Thread {
    public MyThread(String name) {
        super(name);
    }
    @Override
    public void run() {
        for(int i = 1; i <= 4; i++){
            System.out.println("I am " + getName());
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                return;
            }
        }
    }
}

运行结果：

I am childThread
I am childThread
I am childThread
I am childThread
I am the mainThread
I am the mainThread
I am the mainThread
I am the mainThread

等待线程结束后，再恢复当前线程的运行。

七、yield()：让出 CPU，当前线程进入就绪状态队列等待，给其他线程执行的机会(就让很小的一个时间片段)。

class TestThread {
    public static void main(String[] args) {
        MyThread my1 = new MyThread("t1");
        MyThread my2 = new MyThread("t2");
        my1.start();
        my2.start();
    }
}
class MyThread extends Thread {
    public MyThread(String s) {
        super(s);
    }
    @Override
    public void run() {
        for(int i = 1; i <= 20; i++){
            System.out.println(getName()+":"+i);
            if(i % 5 == 0) {
                Thread.yield(); // 当前线程让出 CPU 一小会儿
            }
        }
    }  
}

八、wait()：它会释放掉对象的锁

当前的线程必须拥有当前对象的 monitor，也即 lock，就是锁。线程调用 wait()，释放它对锁的拥有权，使得当前线程必须要等待。然后等待另外的线程调用 notify() 或者 notifyAll() 来通知它，这样它才能重新获得锁的拥有权和恢复执行。要确保调用 wait() 的时候拥有锁，即：wait() 的调用必须放在synchronized 方法或 synchronized 块中。

区别：
1️⃣当线程调用了 wait() 时，它会释放掉对象的锁。
2️⃣另一个会导致线程暂停的方法：Thread.sleep()，它会导致线程睡眠指定的毫秒数，但在睡眠的过程中是不会释放掉对象的锁的。
3️⃣wait() 和 notify()/notifyAll() 在释放对象锁的区别在于：wait() 立即释放，notify()/notifyAll() 则会等待线程剩余代码执行完毕才会释放。

九、notify()/notifyAll()：唤醒对象的 wait pool 中的一个/所有等待线程

notify() 会唤醒一个等待当前对象的锁的线程。如果多个线程在等待，它们中的一个将会选择被唤醒。这种选择是随意的，和具体实现有关(线程等待一个对象的锁是由于调用了 wait() 中的一个)。被唤醒的线程是不能被执行的，需要等到当前线程放弃这个对象的锁。被唤醒的线程将和其他线程以通常的方式进行竞争，来获得对象的锁。也就是说，被唤醒的线程并没有什么优先权，也没有什么劣势，对象的下一个线程还是需要通过一般性的竞争。

notify() 应该是被拥有对象的锁的线程所调用This method should only be called by a thread that is the owner of this object's monitor。换句话说，和 wait() 一样，notify() 调用必须放在 synchronized 方法或 synchronized 块 中。

为何 wait()、notify()/notifyAll() 要在同步块中被调用？

这是 JDK 强制的，wait() 和 notify()/notifyAll() 在调用前都必须先获得对象的锁。

十、终止线程的方法

  1. 正常运行结束，线程自动结束。

  2. 使用退出标志退出线程
    一般 run() 执行完，线程就会正常结束。然而，常常有些线程是伺服线程，需要长时间运行，只有在外部某些条件满足的情况下，才能被关闭。使用一个变量来控制循环，例如：最直接的方法就是设一个boolean型的标志，通过该标志控制 while 循环是否退出。

public class ThreadSafe extends Thread { 
    public volatile boolean exit = false;  
        public void run() {  
        while (!exit){ 
            //do something 
        } 
    }  
}

定义默认值为 false 的退出标志 exit，当其为 true 时，while 循环退出。在定义 exit 时，使用Java关键字volatile修饰，确保同一时刻只能由一个线程修改 exit 的值。

  1. 使用interrupt()来中断线程(两种情况)

a.线程处于阻塞状态
如使用了 sleep，同步锁的 wait，socket 的 receiver、accept 等方法时，会使线程处于阻塞状态。当调用线程的 interrupt() 时，阻塞的方法会抛出 InterruptedException，通过代码捕获该异常，然后 break 跳出循环状态，从而有机会结束线程的执行。通常很多人认为只要调用 interrupt 方法线程就会结束，实际上是错的，一定要先捕获InterruptedException之后通过 break 来跳出循环，才能正常结束 run 方法。

b.线程未处于阻塞状态
使用 isInterrupted() 判断线程的中断标志来退出循环。当使用 interrupt() 时，中断标志就会置true，和使用自定义的标志来控制循环是一样的道理。

public class ThreadSafe extends Thread {
	public void run() {
    	while (!isInterrupted()){ //非阻塞过程中通过判断中断标志来退出 
            try{ 
                Thread.sleep(5*1000);//阻塞过程捕获中断异常来退出 
            }catch(InterruptedException e){ 
                e.printStackTrace(); 
                break;//捕获到异常之后，执行break跳出循环 
            } 
        } 
    }  
}
  1. stop 方法终止线程(线程不安全)
    直接使用 thread.stop() 来强行终止线程，但是该方法很危险，就象突然关闭计算机电源，而不是按正常程序关机一样，可能会产生不可预料的结果。不安全主要是：thread.stop() 调用之后，创建子线程的线程就会抛出 ThreadDeatherror，并且会释放子线程所持有的锁。一般任何进行加锁的代码块，都是为了保护数据的一致性，如果在调用 thread.stop() 后导致了该线程所持有的锁的突然释放(不可控制)，那么被保护数据就有可能呈现不一致性，其他线程在使用这些被破坏的数据时，有可能导致一些很奇怪的应用程序错误。因此，并不推荐使用 stop 方法。

十一、一个线程变为一个对象的锁的拥有者的三种方法

  1. 执行该对象的 synchronized 实例方法。
  2. 执行该对象的 synchronized 语句块(语句块锁的是该对象，如 synchronized(object))
  3. 对于 Class 类的对象，执行该类的 synchronized、static方法。

十二、Daemon Thread(守护线程)

Java 中有两类线程：User Thread(用户线程)、Daemon Thread(守护线程)。用户线程即运行在前台的线程，而守护线程是运行在后台的线程。守护线程的作用是为其他前台线程的运行提供便利服务，而且仅在普通、非守护线程仍然运行时才需要，比如垃圾回收线程就是一个守护线程。当JVM检测仅剩一个守护线程，而用户线程都已经退出运行时，JVM 就会退出，因为没有了被守护者，也就没有继续运行程序的必要了。如果有非守护线程仍然存活，JVM 就不会退出。

守护线程必须在它的 start() 之前通过 setDaemon(true) 进行设置。

//守护线程：在线程启动前设置setDaemon(true)
public class Demo6 {
	public static void main(String[] args) throws Exception {
		ThreadH th = new ThreadH();
		th.setDaemon(true);// 将当前线程设置为守护线程
		th.start();
		for (int i = 0; i < 10; i++) {
			Thread.sleep(1000);
			System.out.println("主线程。。。" + i);
		}
	}
}
class ThreadH extends Thread {
	int i;
	@Override
	public void run() {
		while (true) {
			try {
				sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println("Hello,---" + ++i);
		}
	}
}

十三、如何检测一个线程是否持有对象锁

Thread 类提供了一个 holdsLock(Object obj)，当且仅当对象 obj 的监视器被某条线程持有的时候才会返回 true。这是一个 static 方法，这意味着“某条线程”指的是当前线程。

十四、如何唤醒一个阻塞的线程

如果线程是因为调用了 wait()、sleep() 或者 join() 而导致的阻塞，可以中断线程，并且通过抛出InterruptedException来唤醒它。如果线程遇到了 IO 阻塞，无能为力，因为 IO 是操作系统实现的，Java 代码并没有办法直接接触到操作系统。

十五、Thread 类中的 start() 和 run() 的区别

1️⃣start() 来启动线程，真正实现了多线程运行。该方法会在内部调用 Runnable 接口的 run()，以在单独的线程中执行 run() 中指定的代码。此时无需等待 run 方法体代码执行完毕，可以直接继续执行下面的代码。调用 start() 启动线程，此时该线程处于就绪状态，并没有运行。然后通过此 Thread 类调用 run() 来完成其运行操作的，这里 run() 称为线程体，它包含了要执行的这个线程的内容，run() 运行结束，此线程终止。然后 CPU 再调度其它线程。start() 启动线程执行以下任务：

● 它统计了一个新线程
● 线程从 New State 移动到 Runnable 状态。
● 当线程有机会执行时，它的目标 run() 将运行。

2️⃣run() 当作普通方法的方式调用。程序顺序执行，要等待 run 方法体执行完毕后，才可继续执行下面的代码；程序中只有主线程——这一个线程，其程序执行路径还是只有一条，这样就没有达到写线程的目的。

调用 start() 才可启动线程，而 run() 只是 thread 的一个普通方法调用，还是在主线程里执行。把需要并行处理的代码放在 run() 中，start() 启动线程将自动调用 run() ，这是由JVM的内存机制规定的。并且 run() 必须是 public 访问权限，返回值类型为 void。

3️⃣区别
①方法的定义
start() 在java.lang.Thread类中定义；而 run() 在java.lang.Runnable接口中定义，必须在实现类中重写。

②新线程创建
当程序调用 start() 时，才会表现出多线程的特性，此时创建一个新线程，然后执行 run()。如果直接调用 run()，则不会创建新的线程，run() 将作为当前调用线程本身的常规方法调用执行，并且不会发生多线程。示例：

class MyThread extends Thread {
   public void run() {
     System.out.println("\n");
     System.out.println("当前线程的名称: "
       + Thread.currentThread().getName());
     System.out.println("run()方法调用");
    }
}
class demo {
   public static void main(String[] args) {
     MyThread t = new MyThread();
     t.start();
   }
}

当调用线程类实例的 start() 时，会创建一个新的线程，默认名称为 Thread-0，然后调用 run()，并在其中执行所有内容。新创建的线程。

现在，尝试直接调用 run() 而不是 start()：

class MyThread extends Thread {
   public void run() {
     System.out.println("\n");
     System.out.println("当前线程的名称: "
       + Thread.currentThread().getName());
     System.out.println("run()方法调用");
   }
}
class GeeksforGeeks {
   public static void main(String[] args) {
     MyThread t = new MyThread();
     t.run();
   }
}

当调用 MyThread 类的 run() 时，没有创建新线程，并且在当前线程即主线程上执行 run()。因此，没有发生多线程。run() 是作为正常函数被调用。

③多次调用
start() 不能多次调用，否则抛出java.lang.IllegalStateException。run() 可以进行多次调用，因为它只是一种正常的方法调用。

JFS_Study
关注
  • 3
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
多线程控制方法
10-27
主要介绍start、sleep()、jion()、yield()等调用线程方法。
C#控制台下测试多线程的方法
12-25
本文实例讲述了C#控制台下多线程实现方法。分享给大家供大家参考。具体如下： class Program { static void Main(string[] args) { ThreadStart num = new ThreadStart(PrintNum); Thread ConstrolNum = new Thread(num); ThreadStart str = new ThreadStart(PrintStr); Thread ConstrolStr = new Thread(str); Stopwatch watch = new Stop
关于多线程常用方法以及对锁的控制(详解)
08-30
下面小编就为大家带来一篇关于多线程常用方法以及对锁的控制(详解)。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
C# 多线程对资源读写时如何控制的方法
01-19
1、多个线程对同一个队列进行读写操作，要注意进行读写控制，某个线程在读取的时候，不允许其它线程读、写；某个线程在写的时候，不允许其它线程进行读写。 2、对字典进行读写时，进行独占式访问定义一个字典，再定义用于指定用于对此字典进行读写控制的ReaderWriterLockSlim对象 ReaderWriterLockSlim类的说明 如下图所示，在读取前，执行EnterReadLock()进入读取锁定模式，读完后，执行ExitReadLock()退出读取模式。如果是要写入，则执行该锁定对象的EnterWriteLock()、ExitWriteLock()方法。这样实现锁定对象与字典的对应。
线程的控制
qq_51263139的博客
04-25 549
目录 Thread.yield()方法：控制线程主动让出CPU。 通知线程停止的方式 应该考虑使用多线程的场景： 线程基本知识小结： Thread.yield()方法：控制线程主动让出CPU。 创建两个线程，不加Thread.yield()方法，CPU基本上是公平的，两个线程运行效率基本对等： public class Main { static class PrintWhoAmI extends Thread { private final String who
线程控制的基本方法
LiLiYuan.的博客
09-03 1037
程序每次的运行结果可能是不一样的。这是因为多个线程在执行时会抢占 CPU 资源，抢到之后才会执行。而程序员是无法精准控制这种抢夺情况的。尽管如此，Thread 类还提供了一些线程控制方法，虽不能精准控制线程的抢夺情况，但能够帮助我们更好的控制线程。 > void start()：使该线程开始执行，Java 虚拟机负责调用该线程的 run() 方法。 void sleep(long > millis)：静态方法，线程进入阻塞状态，在指定时间（单位为毫秒）到达之后进入就绪状态。 void >
【Linux】线程控制篇
Suk_god的博客
04-14 1513
文章目录1、线程创建1.1 接口介绍1.2测试入口函数的传参1.2.1 创建线程，查看线程的相关信息1.2.2 创建多个线程，通过传变量的值区分每一个线程1.2.2.1 传递局部变量1.2.2.2 传递全局变量1.2.2.3 传递堆空间开辟的变量1.2.3 入口函数传参的结论2、线程终止2.1 接口介绍2.2 场景模拟3、线程等待3.1 接口介绍3.2 代码测试4、线程分离4.1 接口介绍4.2 代码测试 1、线程创建 1.1 接口介绍 int pthread_create( pthread_t *thr
线程控制
diaofoulu2041的博客
09-13 184
目录 1. 线程与进程 线程的概念 深入理解进程和线程 2. 多线程 什么是多线程 多线程模型的好处 3. 线程标识 4. 线程创建 函数原型 参数说明 ...
线程的控制(常见方法)
LFSenior
03-04 3561
线程的控制(常见方法) 休眠线程、加入线程、礼让线程、后台线程 A:休眠线程 public static void sleep(long millis)：在指定的毫秒数内让当前正在执行的线程休 眠（暂停执行）， 此操作受到系统计时器和调度程序精度和准确性的影响。  该线程不丢失任何监视器的所属权。  Eg：Thread.sleep(1000); B:加入线程 public fina
Java 控制线程的方法
08-19
主要介绍了Java 控制线程的方法，文中讲解非常细致，代码帮助大家更好的理解和学习，感兴趣的朋友可以了解下
控制线程的常用方法
zhanxiaoyier的博客
11-30 781
线程的控制 1. join线程 让一个线程等待另一个线程完成的方法：例如，main线程中调用a线程的join方法后，那么在a线程结束后，main才会继续运行(如果还有其他线程，其他线程与她两无关)。 public static void main(String[] args) throws InterruptedException { Thread thread=new...
线程控制的三个方法。
weixin_46220463的博客
02-16 379
1，加入sleep();方法： sleep方法和wait方法的异同点： 相同点， 都可以使线程处于冻结状态。 异同点 ： 1，sleep可以指定时间，wait可以指定时间，也可以不指定时间。 2，sleep是时间到了，线程处于阻塞状态或者运行。 wait如果没有指定时间，必须通过notify和notifyAll唤醒。 3，sleep不一定非要定义在同步中。 wait一定定义在同步中。 4，都定义...
如何进行线程管理
最新发布
m0_75087854的博客
04-20 827
使用标识，去标识线程可能是为了区别线程，假设一个线程执行的同时，另外一个相同的线程也来执行，那么这边造成一定的时间开销与空间开销，所以标识线程主要是为了区别线程，防止同一个线程被执行两次。总而言之，标识线程主要是。而释放资源往往是我们程序员往往忽视的环节，在前期C++学习中，我们熟知，智能指针也是自动进行资源回收的对象，其实了解过智能指针的小伙伴都知道，其实销毁智能指针的操作，就是在析构函数中实现的，其实这也就是C++之父提出的RAII机制，它是充分利用了局部对象自动销毁的特性来控制资源的生命周期的。
java子线程和主线程同步_Java多线程和同步的理解
weixin_32915575的博客
02-27 495
一、 进程与线程在谈论线程之前，我们先来看看什么叫进程，以及进程与线程的关系。进程我们在windows操作系统中打开任务管理器，可以看到有一项是“进程”，里面列举出了用户目前正在运行的所有进程，包括系统进程和用户应用程序进程，以及每个进程所占用的内存资源等信息。进程是操作系统结构的基础，它不仅只包括运行的程序代码，还包括当前的活动。对于每一个进程，操作系统都会为其分配一个独立的内存块，各...
2.Java面试题—并发基础、【同步 & 互斥】、JUC & 并发容器、【线程池】、【Lambda表达式】、方法引用、Stream流
页川叶川
02-03 604
死锁是指两个或两个以上的进程在执行过程中，由于竞争资源而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态。所有的Java代码都是在一个叫做Java虚拟机的东西上执行的。虚拟机是一种抽象化的计算机，通过在实际的计算机上仿真模拟各种计算机功能来实现的。
线程 之 线程控制
weixin_43247990的博客
10-27 148
下面有几种方法可以很好的控制线程的执行。 1.join 线程控制 2.后台线程（守护线程） 3.sleep线程睡眠 4.yield线程让步 1.join 线程控制。 Thread提供了让一个线程等待另外一个线程完成的方法-------join()方法 意思：当在a程序执行流（线程）中调用b线程的jion()方法，调用者(a)就会被阻塞（出于冻结状态），直到jion() 线程(b)被执行完为止。 ...
线程控制四种方法
l_z_chen的博客
06-24 300
Java四种线程池的使用 博客分类：  JDK java线程线程池监控  Java通过Executors提供四种线程池，分别为： newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。 newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中
java线程sleep方法
09-08
Java线程的sleep方法是一个静态方法，用于让当前线程进入休眠状态。它的作用是让当前线程暂停执行一段时间，放弃CPU的时间片，让其他线程有机会执行。sleep方法的参数是毫秒数，表示线程要休眠的时间长度。 sleep方法通常被用于控制线程的执行顺序、模拟并发场景或者在需要等待一段时间后再执行某些操作的情况下。它主要适用于在run方法内部使用，这样可以让该线程在执行过程中进入休眠状态。 需要注意的是，sleep方法只会让当前线程休眠，而不是其他线程。即使在Runner1的run方法中不写sleep方法，在主线程中调用Runner1.sleep(5000)，也只会让主线程进入休眠状态，而不是Runner1线程。因此，调用sleep方法时要确保是在当前线程中调用。<span class="em">1</span><span class="em">2</span><span class="em">3</span><span class="em">4</span>

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

JFS_Study

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

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

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

打赏作者

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

抵扣说明：

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

余额充值