public synchronized String pop(){
this.notifyAll();// 唤醒对象等待池中的所有线程，可能唤醒的就是

生产者（当生产者发现产品满，就会进入对象的等待池，这里

代码省略，基本略同） while(index == -1){//如果发现没产品，

就释放锁，进入对象等待池
this.wait();
}//当生产者生产完后，消费者从this.wait()方法再开始执行，

第一次还会执行循环，万一产品还是为空，则再等待，所

以这里必须用while循环，不能用if String good = buffer[index];
buffer[index] = null; index--;
return good;// 消费完产品，退出。
}

public class AtomicIdGenerator{
private final AtomicInter counter = new AtomicInteger(0);
public int getNext(){
return counter.getAndIncrement();
}
}
// getAndIncrement方法的内部实现方式，这也是CAS方法的

一般模式，CAS方法不一定成功，所以包装在一个无限循

环中，直到成功
public final int getAndIncrement(){
for(;;){
int current = get();
int next = current +1;
if(compareAndSet(current,next))
return current;
}
}

public class TreeNode{
private volatile TreeNode parent;
// 静态工厂方法
private static final AtomicReferenceFieldUpdater<TreeNode,

TreeNode> parentUpdater = AtomicReferenceFieldUpdater.

newUpdater(TreeNode.class,

TreeNode.class,"parent");
public boolean compareAndSetParent(TreeNode expect,

TreeNode update){
return parentUpdater.compareAndSet(this, expect, update);
}
}

public class LockIdGenrator{
//new ReentrantLock(true)是重载，使用更加公平的加锁机制，

在锁被释放后，会优先给等待时间最长的线程，避免一些

线程长期无法获得锁
private int ReentrantLock lock = ReentrantLock();
privafte int value = 0;
public int getNext(){
lock.lock(); //进来就加锁，没有锁会等待
try{
return value++;//实际操作
}finally{
lock.unlock();//释放锁
}
}
}

public class SimpleResourceManager{
private final InnerSynchronizer synchronizer;
private static class InnerSynchronizer extends

AbstractQueuedSynchronizer{
InnerSynchronizer(int numOfResources){
setState(numOfResources);
}
protected int tryAcquireShared(int acquires){
for(;;){
int available = getState();
int remain = available - acquires;
if(remain <0 || comapreAndSetState(available, remain){
return remain;
}
}
}
protected boolean try ReleaseShared(int releases){
for(;;){
int available = getState();
int next = available + releases;
if(compareAndSetState(available,next){
return true;
}
}
}
}
public SimpleResourceManager(int numOfResources){
synchronizer = new InnerSynchronizer(numOfResources);
}
public void acquire() throws InterruptedException{
synchronizer.acquireSharedInterruptibly(1);
}
pubic void release(){
synchronizer.releaseShared(1);
}
}

public class PageSizeSorter{
// 并发性能远远优于HashTable的 Map实现，hashTable做任何操作

都需要获得锁，同一时间只有有个线程能使用，而Concurrent

HashMap是分段加锁，不同线程访问不同的数据段，完全不

受影响，忘记HashTable吧。
private static final ConcurrentHashMap<String , Interger>

sizeMap = new ConcurrentHashMap<>();
private static class GetSizeWorker implements Runnable{
private final String urlString;
public GetSizeWorker(String urlString , CountDownLatch

signal){
this.urlString = urlStirng;
this.signal = signal;
}
public void run(){
try{
InputStream is = new URL(urlString).openStream();
int size = IOUtils.toByteArray(is).length;
sizeMap.put(urlString, size);
}catch(IOException e){
sizeMap.put(urlString, -1);
}finally{
signal.countDown()://完成一个任务 ， 任务数-1
}
}
}
private void sort(){
List<Entry<String, Integer> list = new ArrayList<sizeMap.

entrySet());
Collections.slort(list, new Comparator<Entry<String,Integer

>>(){
public int compare (Entry<String, Integer> o1, Entry<Sting ,

Integer> o2){
return Integer.compare(o2.getValue(),o1.getValue());
};
System.out.println(Arrays.deepToString(list.toArray()));
}
public void sortPageSize(Collection<String> urls) throws

InterruptedException{
CountDownLatch sortSignal = new CountDownLatch

(urls.size());
for(String url: urls){
new Thread(new GetSizeWorker(url, sortSignal)).start();
}
sortSignal.await()://主线程在这里等待，任务数归0，

则继续执行
sort();
}
}

public class PrimeNumber{
private static final int TOTAL_COUTN = 5000;
private static final int RANGE_LENGTH= 200;
private static final int WORKER_NUMBER = 5;
private static volatitle boolean done = false;
private static int rangeCount = 0;
private static final List<Long> results = new ArrayList<Long>():
private static final CyclicBarrier barrier = new CyclicBarrie

r(WORKER_NUMBER, new Runnable(){
public void run(){
if(results.size() >= TOTAL_COUNT){
done = true;
}
}
});
private static class PrimeFinder implements Runnable{
public void run(){
while(!done){// 整个过程在一个 while循环下，await()等待，

下次循环开始，会再次判断 执行条件
int range = getNextRange();
long start = rang * RANGE_LENGTH;
long end = (range + 1) * RANGE_LENGTH;
for(long i = start; i<end;i++){
if(isPrime(i)){
updateResult(i);
}
}
try{
barrier.await();
}catch (InterruptedException | BokenBarrierException e){
done = true;
}
}
}
}
private synchronized static void updateResult(long value){
results.add(value);
}
private synchronized static int getNextRange(){
return rangeCount++;
}
private static boolean isPrime(long number){
//找质数的代码
}
public void calculate(){
for(int i=0;i<WORKER_NUMBER;i++){
new Thread(new PrimeFinder()).start();
}
while(!done){

}
//计算完成
}
}

public class SendAndReceiver{
private final Exchanger<StringBuilder> exchanger

= new Exchanger<StringBuilder>();
private class Sender implements Runnable{
public void run(){
try{
StringBuilder content = new StringBuilder("Hello");
content = exchanger.exchange(content);
}catch(InterruptedException e){
Thread.currentThread().interrupt();
}
}
}
private class Receiver implements Runnable{
public void run(){
try{
StringBuilder content = new StringBuilder("World");
content = exchanger.exchange(content);
}catch(InterruptedException e){
Thread.currentThread().interrupt();
}
}
}
public void exchange(){
new Thread(new Sender()).start();
new Thread(new Receiver()).start();
}
}

public class FileDownloader{
// 线程池
private final ExecutorService executor = Executors.

newFixedThreadPool(10);
public boolean download(final URL url, final Path path){
Future<Path> future = executor.submit(new Callable

<Path>(){ //submit提交任务
public Path call(){
//这里就省略IOException的处理了
InputStream is = url.openStream();
Files.copy(is, path, StandardCopyOption.REPLACE

_EXISTING);
return path;
});
try{
return future.get() !=null ? true : false;
}<span style="font-family: Arial, Helvetica, sans-serif;"

>catch(InterruptedException | ExecutionException e){</span>
return false;
}
}
public void close(){//当不再使用FileDownloader类的对

象时，应该使用close方法关闭其中包含的ExecutorService

接口的实现对象，否则虚拟机不会退出，占用内存不释放
executor.shutdown();// 发出关闭请求，此时不会再接受新任务
try{
if(!executor.awaitTermination(3, TimeUnit.MINUTES)

){// awaitTermination 来等待一段时间，使正在执行的任务

或等待的任务有机会完成
executor.shutdownNow();// 如果等待时间过后还有任务

没完成，则强制结束
executor.awaitTermination(1, TimeUnit.MINUTES)

;// 再等待一段时间，使被强制结束的任务完成必要的清理工作
}
}catch(InterruptedException e){
executor.shutdownNow();
Thread.currentThread().interrupt();
}
}
}

public class WebPageImageDownloader{
private final Phaser phaser = new Phaser(1);//初始参与数1，

代表主线程。
public void download(URL url, final Path path) throws IOException{
String content = getContent(url);//获得HTML文本，省略。
List<URL> imageUrls = extractImageUrls(content);//获得图片

链接，省略。
for(final URL imageUrl : imageUrls){
phaser.register();//子线程注册
new Thread(){
public void run(){
phaser.arriveAndAwaitAdvance();//第二阶段的等待，

等待进入第三阶段
try{
InputStream is = imageUrl.openStream();
File.copy(is, getSavePath(path, imageUrl), Standard

CopyOption.REPLACE_EXISTING);
}catch(IOException e){
e.printStackTrace():
}finally{
phaser.arriveAndDeregister();//子线程完成任务，退出。
}
}
}.start();
}
phaser.arriveAndAwaitAdvance();//第二阶段等待，子线程在注册
phaser.arriveAndAwaitAdvance();//第三阶段等待，子线程在下载
phaser.arriveAndDeregister();//所有线程退出。
}
}

public class ThreadLocalIdGenerator{
private static final ThreadLocal<IdGenerator> idGenerator = new ThreadLocal<IdGenerator>(){
protected IdGenerator initalValue(){
return new IdGenerator();//IdGenerator 是个初始int value =0,

然后getNext(){ return value++}
}
};
public static int getNext(){
return idGenerator.get().getNext();
}
}