Java并发学习笔记（1）——并发编程基础

1. 线程的状态

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);
    }