Java线程常用方法 原创

wait(long millis)

public final native void wait(long timeout) throws InterruptedException;

总结：

（1）调用wait(long millis)声明在Object类中的final本地native方法，不可重写，而且必须由锁对象调用。  

（3）调用wait(long millis)，需要通过其他线程调用notify()或者notifyAll()方法唤醒当前等待中的线程，或者等待限制时间结束后，才有机会获取CPU使用权，可以进入其他状态。

（4）通过notify/notifyAll() 的执行只是唤醒沉睡的线程，而不会立即释放锁。  只是告诉调用过wait方法的线程可以去参与获得锁的竞争了，但不是马上得到锁，因为别人锁还没释放。

notify()/notifyAll() ---线程唤醒

public final native void notify();

public final native void notifyAll();

翻译一下

唤醒的是那个线程？

wait()和notify()配合使用

sleep(long millis) ---线程休眠

public static native void sleep(long millis) throws InterruptedException;

源码注释

（2）调用sleep(long millis)的线程休眠millis毫秒，调用线程会暂时让出CPU的执行权，期间不参与CPU的调度，休眠millis毫秒。

（3） 调用sleep(long millis)的线程持有的锁是不让出的。时间到了会正常返回，线程就会处于就绪状态，然后参与CPU调度，获取到CPU资源之后就可以进入运行状态。
（4）sleep(long millis) 中指定的时间是线程不会运行的最短时间。 sleep(long millis) 方法不能保证该线程睡眠到期后就开始执行。

（5） sleep(long millis) 醒来之后是立即执行（立即执行说的sleep(long millis)是不需要进行抢锁操作，并不是立即进入运行状态，而是进入可运行状态，首先进入就绪状态，抢到CPU的执行权才能进入运行状态。），而wait()被唤醒之后还需要再抢到锁之后执行。

例如：在main方法中，线程A调用sleep(2000)休眠2s，这2s内其他线程如main（或其他线程）可以运行，线程A不参与竞争，2s过后，线程A可以和线程main等线程公平的争夺CPU的使用权，获取后才能进入运行状态。

以下照抄自
https://blog.csdn.net/wxwzy738/article/details/8628443

sleep就是正在执行的线程主动让出cpu，cpu去执行其他线程，在sleep指定的时间过后，cpu才会回到这个线程上继续往下执行，如果当前线程进入了同步锁，sleep方法并不会释放锁，即使当前线程使用sleep方法让出了cpu，但其他被同步锁挡住了的线程也无法得到执行。

wait是指在一个已经进入了同步锁的线程内，让自己暂时让出同步锁，以便其他正在等待此锁的线程可以得到同步锁并运行。

只有其他线程调用了notify方法（notify并不释放锁，只是告诉调用过wait方法的线程可以去参与获得锁的竞争了，但不是马上得到锁，因为锁还在别人手里，别人还没释放。如果notify方法后面的代码还有很多，需要这些代码执行完后才会释放锁，可以在notfiy方法后增加一个等待和一些代码，看看效果），调用wait方法的线程就会解除wait状态和程序可以再次得到锁后继续向下运行。

sleep()和wait()方法的区别：

1，sleep()声明在Thread类中的静态方法；wait()声明在Object类中，而且必须由锁对象调用。（两个方法带参数的都是本地方法，wait()不带参数的调用的是带参数的本地方法）
2、sleep()等待的时候，不会释放锁；wait()等待过程中释放锁（同步锁，每个对象有唯一的锁）。
3、wait()和notify()必须在同步中调用（不然会报错InterruptedException）。

Join()/join(long millis) ---线程插队

join()

public final void join() throws InterruptedException {
join(0);
}

例如：main方法中，有一个线程A，调用strat()，然后马上join()，那么，main线程就该等待，直到线程A执行完毕，main才可以执行。

join(long millis)

public final synchronized void join(long millis) throws InterruptedException {}  

（1）join(long millis)方法是一个同步方法。

（2）此线程（调用join(long millis)的）等待millis 毫秒后终止线程，假如这段时间内该线程还没执行完，那么其他线程结束等待，多个线程并发（交替的）执行；
（3）millis参数等于0时候，相当于join()无参方法，直到该线程执行完。

假如：main方法中，线程A调用join(2000)等待2s，如果线程A还没执行完，main停止等待，将和线程A一起并发执行。

yield() --线程让步

public static native void yield();

可能进入阻塞状态的情况：

详情可点击查看

线程终止方法（三种）

1、使用标志终止线程，在run方法中通过一个标记来进行结束；

2、使用interrupt终止线程
3、stop() 废弃了

Thread.stop, Thread.suspend, Thread.resume 和Runtime.runFinalizersOnExit  这些终止线程运行的方法已经被废弃。

1、使用标志终止线程

使用标志终止线程，在run方法中通过一个标记来进行结束；

public void run() {
while(flag){
//do something
}
}

2、使用interrupt()终止线程  ---线程中断

public void interrupt() {}

public static boolean interrupted() {
return currentThread().isInterrupted(true);
}

private native boolean isInterrupted(boolean ClearInterrupted); 

 
public boolean isInterrupted() {
return isInterrupted(false);
}  

在java中主要有3个相关方法

在Thread类中   interrupt()   和  interrupted()   和 isInterrupted() 

1、interrupt()，就是中断线程，将会设置该线程的中断状态位，即设置为true。中断的结果就取决于这个程序本身。线程会不时地检测这个中断标示位，以判断线程是否应该被中断（中断标示值是否为true）。它并不像stop方法那样会中断一个正在运行的线程。 

使用说明：

（1）在一个线程A中调用另一个线程B的interrupt()方法（线程B被阻塞才会有用），只会改变线程B的中断状态，它不会中断一个正在运行的线程B。也就是给受阻塞的线程发出一个中断信号，这样受阻线程就得以退出阻塞的状态。

（2）如果线程没有被阻塞，这时调用 interrupt()将不起作用，直到执行到wait(),sleep(),join()时,才马上会抛出 InterruptedException。  

（3）如果线程被Object.wait, Thread.join和Thread.sleep三种方法之一阻塞，此时调用该线程的interrupt()方法，那么该线程将抛出InterruptedException中断异常（该线程必须事先预备好处理此异常InterruptedException）就是在监视线程的中断状态，一旦线程的中断状态被置为“中断状态”，就会抛出中断异常。这一方法实际完成的是，给受阻塞的线程发出一个中断信号，这样受阻线程检查到中断标识，就得以退出阻塞的状态。 

2、interrupted() ，测试当前线程是否已经中断（Thread类，静态方法，返回boolean值）调用之后会改变线程的状态，如果是中断状态调用的，调用之后会清除线程的中断状态（也就是该方法调用后会将中断标示位清除，即重新设置为false）。

3、isInterrupted()，用来判断当前线程的中断状态(true or false)。

例

复制收展Javapackage com.test.mthread;

/**
 * @Desc interrupt()线程中断-累行客
 * @Author luolei
 * @Web http://www.leixingke.com/
 * @Date 2020/07/16 17:27
 * 输出
 * Thread1 Starting...
 * Thread1 is running.
 * Thread1 is running.
 * Thread1 is running.
 * Thread1isInterrupted(): false
 * Thread1isInterrupted(): true
 * throw InterruptedException...
 * Thread1isInterrupted(): false
 * java.lang.InterruptedException: sleep interrupted
 * 	at java.lang.Thread.sleep(Native Method)
 * 	at com.test.mthread.MyThread4.run(InterruptTest.java:54)
 * Handling InterruptedException...
 * Thread1 is exiting...
 * Stopping application...
 */
public class InterruptTest {

    public static void main(String[] args) throws InterruptedException {
        MyThread4 m1 = new MyThread4("Thread1");
        System.out.println(m1.getName() + " Starting...");
        m1.start();
        /*主线程main阻塞3s*/
        Thread.sleep(3000);
        System.out.println(m1.getName() + "isInterrupted(): " + m1.isInterrupted());/* false*/
        /*阻塞时退出阻塞状态，即中断标示位设置为true*/
        m1.interrupt();
        System.out.println(m1.getName() + "isInterrupted(): " + m1.isInterrupted()); /* true*/
        /*如果中断状态调用的，调用之后会清除线程的中断状态，即中断标示位设置为false*/
        m1.interrupted();
        System.out.println(m1.getName() + "isInterrupted(): " + m1.isInterrupted());/* false*/
        Thread.sleep(3000); /*主线程main休眠3秒以便观察线程m1的中断情况*/
        System.out.println("Stopping application...");
    }
}

class MyThread4 extends Thread {
  volatile boolean stop = false;
    public MyThread4(String name) {
        super(name);
    }
    public void run() {
    while (!stop) {
      System.out.println(getName() + " is running.");
      try {
        sleep(1000);
      } catch (InterruptedException e) {
        System.out.println("throw InterruptedException...");
        e.printStackTrace();
        System.out.println("Handling InterruptedException...");
        stop = true; /*修改共享变量的状态，终止线程*/
      }
    }
    System.out.println(getName() + " is exiting...");
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

3、使用stop()、destroy()等方法  ---废弃

@Deprecated
public void destroy() {
throw new NoSuchMethodError();
}

1. 只有在调用线程拥有某个对象的独占锁时，才能够调用该对象的wait(),notify()和notifyAll()方法。
2. 如果不在同步代码块中使用，会抛出IllegalMonitorStateException异常。

（4）synchronized 和 ReentrantLock 有什么不同？

说明：如果一个线程获得了对象锁，进入了同步块，其他访问该同步块的线程都必须阻塞在同步块外面等待，而进行线程阻塞和唤醒的代价是比较高的。

两者区别：

1、这两种方式最大区别就是对于Synchronized来说，它是java语言的关键字，是原生语法层面的互斥，需要JVM实现。而ReentrantLock它是JDK 1.5之后提供的API层面的互斥锁，需要lock()和unlock()方法配合try/finally语句块来完成。

2、由于ReentrantLock是java.util.concurrent包下提供的一套互斥锁，相比Synchronized，ReentrantLock类提供了一些高级功能

（1）等待可中断，持有锁的线程长期不释放的时候，正在等待的线程可以选择放弃等待，这相当于Synchronized来说可以避免出现死锁的情况。
（2）公平锁，多个线程等待同一个锁时，必须按照申请锁的时间顺序获得锁，Synchronized锁是非公平锁，ReentrantLock默认的构造函数是创建的非公平锁，可以通过参数true设为公平锁，但公平锁表现的性能不是很好。
（3）锁绑定多个条件，一个ReentrantLock对象可以同时绑定对个对象。