1.synchronized void f()
2.使用Lock，更好的管理异常；尝试获取锁一段时间；
private Lock lock = new ReentrantLock();
public int next() {
lock.lock();
try {
++currentEvenValue;
Thread.yield(); // Cause failure faster
++currentEvenValue;
return currentEvenValue;
} finally {
lock.unlock();
}
尝试获取锁最终未获取锁：
captured = lock.tryLock(2, TimeUnit.SECONDS);
更细粒度的控制；
3.volitail保证了可视性（尤其在多处理器系统）
4.原子性变量类：AtomicInteger，AtomicLong，AtomicReference
重要方法：
public final boolean compareAndSet(int expect, int update) {
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
这是一个本地方法：
public final native boolean compareAndSwapInt(Object obj, long l, int i, int j);
在硬件层面保证了原子性
5.临界区，也被称为同步代码块
synchronized(this) {
p.incrementX();
p.incrementY();
temp = getPair();
}
优点：相比同步方法，控制粒度更小，其他线程能更多地访问
注意：synchronized块必须给定一个在其上进行同步的对象，最合理的方式是使用其方法正在被调用的当前对象，如果获得了synchronized块的锁，那么该对象其他的synchronized方法和临界区就不能被调用了
6，线程本地存储：ThreadLocal
private static ThreadLocal<Integer> value =
new ThreadLocal<Integer>() {
private Random rand = new Random(47);
protected synchronized Integer initialValue() {
return rand.nextInt(10000);
}
};
public static void increment() {
value.set(value.get() + 1);
}
注意，ThreadLocal并不是一个Map<Thread,value>，而是在当前Thread线程的一个成员变量：
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
ThreadLocal.ThreadLocalMap threadLocals = null;
7.终结任务
Thread.interrupt()
Executor.shutdownNow()--interrupte它启动的所有线程
中断某一个单一任务：
Future<?> f = exec.submit(r);
TimeUnit.MILLISECONDS.sleep(100);
print("Interrupting " + r.getClass().getName());
f.cancel(true); // Interrupts if running
8.线程之间的协作：某些部分必须在其他部分被解决之前解决
wait();
notifyAll();唤醒等待这个锁的所有任务
notify();只有一个等待这个锁的任务会被唤醒
上面这三个方法都是Object类中的方法
9.生产者-消费者与队列
wait与notify可以进行生产者-消费者的模型构建，以一种低级的方式解决了任务互操作的问题，即每次交互时都握手。
更高的抽象级别，是使用同步队列来解决任务协作问题，同步队列在任何时刻都只允许一个任务插入或移除元素。
java.util.concurrent.BlockingQueue接口中提供了这个队列，通常可以使用无界队列LinkedBlockingQueue(通过使用ReentrantLock加锁)，还可以使用ArrayBlockingQueue，它具有固定的尺寸。
当队列为空时，可以自动挂起消费者任务，当队列中有元素时，可以自动恢复消费者任务，比起wait和notity，这种方式简单而可靠（消除了类之间的耦合）。
一个烤面包的示例：
class Toast {
public enum Status { DRY, BUTTERED, JAMMED }
private Status status = Status.DRY;
private final int id;
public Toast(int idn) { id = idn; }
public void butter() { status = Status.BUTTERED; }
public void jam() { status = Status.JAMMED; }
public Status getStatus() { return status; }
public int getId() { return id; }
public String toString() {
return "Toast " + id + ": " + status;
}
}
class ToastQueue extends LinkedBlockingQueue<Toast> {}
class Toaster implements Runnable {
private ToastQueue toastQueue;
private int count = 0;
private Random rand = new Random(47);
public Toaster(ToastQueue tq) { toastQueue = tq; }
public void run() {
try {
while(!Thread.interrupted()) {
TimeUnit.MILLISECONDS.sleep(
100 + rand.nextInt(500));
// Make toast
Toast t = new Toast(count++);
print(t);
// Insert into queue
toastQueue.put(t);
}
} catch(InterruptedException e) {
print("Toaster interrupted");
}
print("Toaster off");
}
}
// Apply butter to toast:
class Butterer implements Runnable {
private ToastQueue dryQueue, butteredQueue;
public Butterer(ToastQueue dry, ToastQueue buttered) {
dryQueue = dry;
butteredQueue = buttered;
}
public void run() {
try {
while(!Thread.interrupted()) {
// Blocks until next piece of toast is available:
Toast t = dryQueue.take();
t.butter();
print(t);
butteredQueue.put(t);
}
} catch(InterruptedException e) {
print("Butterer interrupted");
}
print("Butterer off");
}
}
// Apply jam to buttered toast:
class Jammer implements Runnable {
private ToastQueue butteredQueue, finishedQueue;
public Jammer(ToastQueue buttered, ToastQueue finished) {
butteredQueue = buttered;
finishedQueue = finished;
}
public void run() {
try {
while(!Thread.interrupted()) {
// Blocks until next piece of toast is available:
Toast t = butteredQueue.take();
t.jam();
print(t);
finishedQueue.put(t);
}
} catch(InterruptedException e) {
print("Jammer interrupted");
}
print("Jammer off");
}
}
// Consume the toast:
class Eater implements Runnable {
private ToastQueue finishedQueue;
private int counter = 0;
public Eater(ToastQueue finished) {
finishedQueue = finished;
}
public void run() {
try {
while(!Thread.interrupted()) {
// Blocks until next piece of toast is available:
Toast t = finishedQueue.take();
// Verify that the toast is coming in order,
// and that all pieces are getting jammed:
if(t.getId() != counter++ ||
t.getStatus() != Toast.Status.JAMMED) {
print(">>>> Error: " + t);
System.exit(1);
} else
print("Chomp! " + t);
}
} catch(InterruptedException e) {
print("Eater interrupted");
}
print("Eater off");
}
}
public class ToastOMatic {
public static void main(String[] args) throws Exception {
ToastQueue dryQueue = new ToastQueue(),
butteredQueue = new ToastQueue(),
finishedQueue = new ToastQueue();
ExecutorService exec = Executors.newCachedThreadPool();
exec.execute(new Toaster(dryQueue));
exec.execute(new Butterer(dryQueue, butteredQueue));
exec.execute(new Jammer(butteredQueue, finishedQueue));
exec.execute(new Eater(finishedQueue));
TimeUnit.SECONDS.sleep(5);
exec.shutdownNow();
}
}
10.死锁
必须同时满足4个条件：
1.互斥条件：至少有一个资源不能共享
2.至少有一个任务持有一个资源且等待别的资源
3.资源不能被任务抢占
4.必须有循环等待
防止死锁，只需破坏其中一个即可，最容易的方法是破坏第四个条件
11.CountDownLatch
同步多个任务，CountDownLatch设置一个初始计数值，任务调用countDown()减小计数值，直到为0
12.CyclicBarrier
创建一组任务，当这组任务都完成时才能进行下一步
13.DelayQueue
是一种无界阻塞队列，其中的元素只有在到期时才能被取走
14.PriorityBlockingQueue
优先级队列
15.免锁容器
CopyOnWriteArrayList：对容器的修改和读取可以同时发生
存储数组：
private volatile transient Object[] array;//volatile保证可见性
add方法：
public boolean add(E e) {
final ReentrantLock lock = this.lock;
lock.lock();//使用锁
try {
Object[] elements = getArray();//获取旧的数据的副本
int len = elements.length;
Object[] newElements = Arrays.copyOf(elements, len + 1);
newElements[len] = e;
setArray(newElements);//更新数据
return true;
} finally {
lock.unlock();
}
}
CopyOnWriteArraySet：借助CopyOnWriteArrayList实现免锁
ConcurrentHashMap<K, V>：用桶粒度的锁，避免了put和get中对整个map的锁定，尤其在get中，只对一个HashEntry做锁定操作
ConcurrentLinkedQueue
16.乐观加锁：即原子类中的compareAndSet()方法
17.ReadWriteLock：对经常读取的操作进行了优化，但是修改期间仍不能读取