- 线程的状态
NEW:初始状态,线程被new 出来,但还没start()的状态
RUNNABLE:指的是调用了start()方法,但还在等着CPU资源的状态;
RUNNING:一个线程获得了CPU资源,正在走的状态;
TERMINATED:线程对象的run()方法走完了的状态
BLOCKED:线程被阻塞,即该线程把CPU资源让出来,等待其他操作再回来请求CPU的状态、
2.线程通信:
volatile:volatile修饰的变量每次访问的时候都保证是内存中的最新版本,可以理解为“任何一个线程修改了volatile变量,均能使其他线程感知到”。
synchronized:修饰代码块和方法,可以保证是线程同步的。即只能有一个线程进入代码块。
wait/notify:
wait()只能在同步块或方法里面调用,调用wait方法后,该线程阻塞,直到其他线程调用这个对象的notify()方法,那么该线程就回到队列里等待CPU资源。
此处有两个注意的地方:(1)wait()方法需要对调用对象加锁。(2)wait是释放锁的,但其他线程notify他了之后,这个wait的线程也不会继续进行,必须等到notify他的线程离开同步块,才能回到队列里等待cpu调度。(3)从wait方法返回的前提是获得了调用对象的锁。
用伪代码描述生产者-消费者经典模型:
生产者:
synchronized(Object o) {
setCondition();//修改某些条件;
o.notifyAll();
}
消费者:
synchronized(Object o) {
while(condition == false) {
o.wait();
}
doSth();
}
3.Thread.join()
如果一个线程A调用了B.join();,那么A就阻塞,直到B线程的run()执行完,A再继续执行。
写了个小例子,将就看一下啦:
public class Main {//主线程
public static void main(String[] args) {
Thread t1 = new Thread(new MyThread(1));
Thread t2 = new Thread(new MyThread(2));
t1.start();t2.start();
System.out.println("t1,t2要来啦!!");
try {
t1.join();
t2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Main");
}
}
public class MyThread implements Runnable{//两个子线程
private int tid;
public MyThread(int tid) {
this.tid=tid;
}
@Override
public void run() {
try {
Thread.sleep(1000);//睡1秒,模拟线程中进行的操作
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(tid);
}
}
那么运行这段程序,会看到先输出了
t1,t2要来啦!!
然后等了1秒之后,输出了
1
2
Main
4.ThreadLocal
这东西是一个封装类,把一个对象封装成线程独享的,底层维护的是一个HashMap,其Key是线程的hashcode,value是这个对象的副本。
get和set源码如下,其实和HashMap基本上如出一辙。
public T get() {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
return setInitialValue();
}
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}