线程状态
// Thread.State
public enum State {
// 新建状态;
NEW,
// NEW状态调用start()执行会进入该状态,表示线程所需要的资源都已经准备好;
RUNNABLE,
// 如果在执行过程中遇到了synchronized同步块,就会进入BLOCK阻塞状态,这个时候线程会暂停执行,直到获得锁;
BLOCKED,
//WAITING和TIMED_WAITING都表示等待,区别是WAITING会进入一个无时间限制的等待,TIMED_WAITING会进行有时限的等待
// WAITING的线程 通常是等待一些特殊的事件,比如通过wait()方法的线程正在等待notify()方法,通过join()方法等待的线程则会等待目标线程终止。
//等到了期望的时间线程就会再次执行
WAITING,
TIMED_WAITING,
// 线程执行完毕后,则进入TERMINATED状态,表示结束。
TERMINATED;
}
//线程从NEW状态出发后,不能再回到NEW状态,同理,处于TERMINATED的线程也不能再回到RUNNABLE状态。
线程sleep中断
public void interrupt() //中断线程
public boolean isInterrupted() //判断是否被中断
public static boolean interrupted() //判断是否被中断,并清除当前中断状态
Thread.sleep()由于中断而抛出异常,此时,会清除中断状态。
// Thread
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(){
@Override
public void run() {
while (true){
if(Thread.currentThread().isInterrupted()){
System.out.println("isInterrupted");
break;
}
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
System.out.println("interrupt Exception");
// 重新设置中断状态,sleep由于终端而抛出异常,此时他会清除中断状态,
// 如果不加处理,在下次循环开始的时候就会无法捕捉这个中断,故在异常处理中,再次设置中断状态
Thread.currentThread().interrupt();
}
System.out.println("aaaaa");
Thread.yield();
}
}
};
t1.start();
Thread.sleep(1000);
t1.interrupt();
}
以上代码执行结果:
如果注释掉异常处理的代码Thread.currentThread().interrupt(),即不重新设置中断状态:
从以上两个结果中可以知道,如果在sleep的时候被中断,没有重新设置过中断状态,程序式不会终止执行的,
因为他的中断状态已经被清除,在新的循环开始的时候,无法捕捉到这个中断。
所以严格来讲,线程中断并不会使线程立即退出,而是给线程发出一个通知;
因此我们可以在线程接收到通知后,执行我们想要的操作,然后安全的退出线程,
而不是使用stop()来强制退出,因为强制退出可能会造成数据异常(这个就不举例了)。
wait()和notify()
这两个方法属于Object类,任何对象都可以调用,也就是说任何对象都可以作为线程的监视器。
当在一个对象实例(obj)上调用wait方法后,当前线程就会在当前对象(obj)上等待,他会进入当前对象(obj)的等待队列。当obj.notify被调用时,会从obj的等待队列中随机选择一个线程并将其唤醒,notifyAll唤醒所有。
因为wait和notify必须要先获得一个对象作为线程监视器,所以它必须包含在synchronzied语句中。
T1,T2获取监视器执行线程流程
wait,notify示例
final static Object obj = new Object();
public static void main(String[] args) {
new T1().start();
new T2().start();
}
static class T1 extends Thread {
@Override
public void run() {
synchronized (obj) {
System.out.println(System.currentTimeMillis() + ": T1 start!");
try {
System.out.println(System.currentTimeMillis() + ": T1 wait for obj");
obj.wait();
} catch (InterruptedException e) {
}
}
System.out.println(System.currentTimeMillis() + ": T1 end");
}
}
static class T2 extends Thread {
@Override
public void run() {
synchronized (obj) {
System.out.println(System.currentTimeMillis() + ": T2 start! notify one Thread");
try {
obj.notify();
System.out.println(System.currentTimeMillis() + ": T2 end");
Thread.sleep(2000);
} catch (InterruptedException e) {
}
}
}
}
结果
从图中时间戳可以看出,T1在输出"T1 end"的时候,是在T2sleep结束之后,也就是说,T2调用notify之后,还没有释放监视器obj。
obj.wait和Thread.sleep都可以让线程等待,除了wait可以被唤醒外,还有个区别就是wait方法回什邡目标对象的锁,而sleep不会释放任何资源。
等待线程结束(join)和谦让(yield)
join
public final void join() //一直阻塞当前线程,直到join的目标线程执行完毕
public final synchronized void join(long millis) //当前线程最多等待millis就会继续执行
demo
public volatile static int i=0;
public static class AddThread extends Thread{
@Override
public void run() {
for(;i<10000;i++){}
}
}
public static void main(String[] args) throws InterruptedException {
AddThread t=new AddThread();
t.start();
t.join();
System.out.println(i);
}
如上代码,如果没有使用t.join,那么主线程可能就直接输出0了,但是使用t.join之后,主线程会等待t的加入并执行完成,此时输出总是10000。
join的本质是让调用线程(示例代码中的main线程)wait在当前线程对象实例上(示例代码中main方法所在的类),被等待的线程(示例中t,main在等待t完成,t是被等待的)会在退出前调用notifyAll通知所有等待的线程继续执行。因此,我们需要注意的是不要再thread对象实例上使用类似的wait或notify等方法,可能会影响系统API或者被系统API影响。
yield
这个方法一旦调用,他会是当前线程让出CPU;但是注意,让出CPU并不表示当前线程不执行。当前线程让出CPU后,还会进行CPU资源争夺,所以让出CPU后有可能又被当前线程抢到资源。
守护线程(Daemon)
守护线程是一种特殊的线程,它主要负责一些系统性的服务,比如垃圾回收线程,JIT线程都可以理解为守护线程。当一个程序用户线程已经全部结束时,也就意味着这个程序已经无事可做了,因此当程序只剩下守护线程时,java虚拟机就会自然退出了。
public static class TDaemon extends Thread {
@Override
public void run() {
while (true) {
try {
System.out.println("aaaaa");
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public static void main(String[] args) throws InterruptedException {
TDaemon t = new TDaemon();
// 如果不设置成守护线程,则t线程就是用户线程,不会随mian线程的结束而结束,会永远循环下去
// 设置成守护线程后,当主线程结束后,该线程就自动退出了
t.setDaemon(true);
t.start();
Thread.sleep(3000);
}
synchronized
指定加锁对象: 对给定对象加锁,进入同步代码前要获得给定对象的锁。
直接作用于实例 方法: 相当于对当前实例加锁,进入同步代码前要获得当前实例的锁。
直接作用于静态方法: 相当于对当前类加锁(静态方法属于类级别调用),进入同步代码前要获得当前类的锁。
注意: 使用该关键字时特别注意,如果要对某部分加锁,一定要注意这些线程使用的锁对象obj是同一个对象哦!!!
注意以下示例
static int i = 0;
public synchronized void incr() {
i++;
}
@Override
public void run() {
for (int j = 0; j < 10000000; j++) {
incr();
}
}
public static void main(String[] args) throws InterruptedException {
Thread t1=new Thread(new ThreadSynchronizedBad());
Thread t2=new Thread(new ThreadSynchronizedBad());
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(i);
}
咋一看没啥问题,但是注意main方法中,两个thread的入参是两个不同的对象,也就是说两个线程都持有自己不同对象的锁,就不会存在竞争,各自运行自己的,最终i的值肯定也就不会是20000000.
修改建议:
1. 把incr()设置成静态方法,对象监视器为当前类。
2. 两个Thread的参数传入同一个new ThreadSynchronizedBad()对象。
神奇的加锁对象Integer
static Integer i = 0;
@Override
public void run() {
for (int j = 0; j < 10000000; j++) {
synchronized (i) {
i++;
}
}
}
public static void main(String[] args) throws InterruptedException {
ThreadIntegerLockBad target = new ThreadIntegerLockBad();
Thread t1=new Thread(target);
Thread t2=new Thread(target);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(i);
}
从上面代码中我们可以看到,我们加锁对象直接是一个Integer类型的对象,怎么看这段代码都毫无问题,这段代码是肯定能够输出20000000这个正确答案的。但是很不幸,结果不会如我们所愿,我们知道任何对象都是可以作为加锁对象的,但是为什么Integer不行,从上述代码中来看我们至始至终都是使用 i 这个对象,我们并没有修改过个对象,为什么不行呢?我们来看一下run()方法反编译的结果。
注意看21~37行,第21行首先调用Integer的intValue得到值,然后执行加一操作,继续在26行上调用了Integer的valueOf方法,实际执行的操作编程了i = Integer.valueOf(i.intVlaue()+1), 而这个方法会返回一个new Integer。
这下子问题清楚了,说明i这个对象其实一直在变,每次加一之后都会返回一个新的对象,这就会导致每次加锁都是一个新的对象,这个锁也就没什么意义了。
当然: 最简单的方式直接把加锁对象换成this就可以解决问题了。
over ...