线程的一些控制方法线程的一些控制方法

文章图片
一、Java 中的线程状态转换
文章图片
【注】不是 start 之后就立刻开始执行，只是就绪了(CPU 可能正在运行其他的线程)。只有被 CPU 调度之后，线程才开始执行，当 CPU 分配给的时间片到了，又回到就绪状态，继续排队等候。
二、线程控制的基本方法
文章图片

isAlive()：判断线程是否还活着。start 之后，终止之前都是活的。
getPriority()：获得线程的优先级数值。
setPriority()：设置线程的优先级数值(线程是有优先级别的)。
Thread.sleep()：将当前线程睡眠指定毫秒数。
join()：调用某线程的该方法，将当前线程与该线程合并，也即等待该线程结束后，再恢复当前线程的运行状态(比如在线程B中调用了线程A的 join()，直到线程A执行完毕后，才会继续执行线程B)。
yield()：当前线程让出 CPU，进入就绪状态，等待 CPU 的再次调度。
wait()：当前线程进入对象的 wait pool。
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 < 10; i++) { System.out.println("ThreadD j---" + i); } } } class ThreadE extends Thread { @Override public void run() { for (int i = 0; i < 10; 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 ThreadE i---5 ThreadE i---6 ThreadE i---7 ThreadE i---8 ThreadE i---9 ThreadD j---1 ThreadD j---2 ThreadD j---3 ThreadD j---4 ThreadD j---5 ThreadD j---6 ThreadD j---7 ThreadD j---8 ThreadD j---9

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

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

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 <= 100; i++){ System.out.println(getName()+":"+i); if(i % 10 == 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() 在调用前都必须先获得对象的锁。
十、一个线程变为一个对象的锁的拥有者的三种方法

执行这个对象的 synchronized 实例方法。
执行这个对象的 synchronized 语句块。这个语句块锁的是这个对象。如 synchronized(object)
对于 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() 来启动线程，真正实现了多线程运行。线程类的 start() 可以用来启动线程；该方法会在内部调用 Runnable 接口的 run()，以在单独的线程中执行 run() 中指定的代码。这时无需等待 run 方法体代码执行完毕，可以直接继续执行下面的代码。通过调用 Thread 类的 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() 可以进行多次调用，因为它只是一种正常的方法调用。