我所知道的高并发

线程的生命周期

NEW（新建状态）

RUNNABLE（运行状态）

BLOCKED（阻赛状态）

WATING（等待状态）

TIMED-WAITING（限时等待状态）

TERMINATED（终止状态）

简单的例子
 Thread t1=new Thread();  #NEW
 t1.start();              有锁 #RUNNABLE; 没锁#BLOCKED
 t1.wait();               #WATING
 t1.notify();             有锁 #RUNNABLE; 没锁#BLOCKED
 t1.wait(1000);           #TIMED-WAITING 等待指定时间后回到#RUNNABLE
 t1.notifyAll();          有锁 #RUNNABLE; 没锁#BLOCKED
 程序执行完毕;              #TERMINATED

新建一个线程在调用start方法前,就是new状态
当调用start方法后就会进入RUNNABLE状态,如果遇到需要锁的情况下,他会进入BLOCKED状态,直到获取到锁之后才会进入RUNNABLE状态
wait和wait(1000)分别会进入WAITING状态和限时TIMED-WAITING状态

---

volatile

用volatile修饰的变量，当变量被修改后能让其他线程知道这个变量的值已经被修改了

但是并不能代替锁，因为无法保证复合操作的原子性。如：i++;

---

Object

wait()

wait（） 能让当线程停止运行，释放锁，并进入WATING状态

wait（long timeout） 能让当线程停止运行，并进入TIMED-WAITING状态，超过指定时间之后继续运行

notify()

随机唤醒一条队列中的线程

notifyAll()

唤醒所有线程

---

Thread

sleep(long millis)

属于Thread的静态方法

能使当前线程停止运行指定时间

注意调用该方法并不会释放锁，wait会释放锁

yield()

有AB2条线程，A持有锁，B等待锁，当A释放锁之后，A还可以再次获得锁。

yield方法的作用就是让A暂时不会获得锁，让B或者其他线程先获取

join()

等待线程终止（TERMINATED）

可以理解成该线程终止后，主线程才会继续执行

join(long millis)；也可设置等待的时间

interrupt()

中断线程

isInterrupted()

判断线程是否被中断

interrupted()

判断是否被中断，并清除当前中断状态。第一调用放回true,之后都是false

---

原子变量类

• AtomicInteger
• AtomicIntegerArray
• AtomicReference
• AtomicIntegerFieldUpdater
• AtomicReferenceFieldUpdater

锁（用于实现线程之间的同步）

synchronized（内置锁）

synchronized（obj）{…}; 进入同步代码块前，需要获得指定对象的锁

作用于实例方法，进入同步代码块前，需要获得当前实例的锁

作用于静态方法，进入同步代码块前，需要获得当前类的锁

ReentrantLock（显示锁）

ReadWriteLock（读写锁）

并发容器

• CopyOnWriteArrayList
• CopyOnWriteArraySet
• ConcurrentHashMap
• ConcurrentLinkedQueue
• HashTable
• Vector

工具类

• Semaphore
• CountDownLatch
• CyclicBarrier
• FutureTask
• LockSuporrt

线程池

• Executor

ThreadLocal