System.out.println("乙不处理，和甲交换，信息：" + info[0]);
}
}
} catch (InterruptedException ex) {
}
}
});
// 程序运行10s后，所有任务停止
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
}
executorService.shutdownNow();
System.out.println("main thread finished");
}
}
第7章：线程间调用Join
第0节：札记
第1节：实例
package com.mcc.core.test.thread;import com.mcc.core.concurrent.ExecutorServiceUtils;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.TimeUnit;
/**
* 一个线程等待另一个线程测试
*
*
* @author menergy
* DateTime: 13-12-31 下午1:09
*/
public class JoinTest {
/**
* A线程
*/
static class AThread implements Runnable{
@Override
public void run() {
try {
System.out.println(" A线程开始处理");
TimeUnit.MILLISECONDS.sleep(2000);
System.out.println(" A线程处理完成");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
/**
* B线程
*/
static class BThread implements Runnable{
private Thread aThread;
public BThread(Thread aThread) {
this.aThread = aThread;
}
@Override
public void run() {
try {
System.out.println("B线程开始处理");
TimeUnit.MILLISECONDS.sleep(1000);
System.out.println("B线程处理到一半，启动A线程，等待A线程处理");
//启动A线程
aThread.start();
//等待A线程完成
aThread.join();
System.out.println("B线程继续处理另一半");
TimeUnit.MILLISECONDS.sleep(1000);
System.out.println("B线程处理完成");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void main(String args[]){
Thread aThread = new Thread(new AThread());
ExecutorService executorService = ExecutorServiceUtils.getExecutor("test", 2);
//启动Ｂ线程
executorService.execute(new BThread(aThread));
}
}
第8章：读写锁ReadWriteLock
第0节：札记
* ReadWriteLock 维护了一对相关的锁，一个用于只读操作，另一个用于写入操作。* 只要没有 writer，读取锁可以由多个 reader 线程同时保持。写入锁是独占的。
* 从理论上讲，与互斥锁相比，使用读-写锁所允许的并发性增强将带来更大的性能提高。
* 与互斥锁相比，使用读-写锁能否提升性能则取决于读写操作期间读取数据相对于修改数据的频率，
* 以及数据的争用――即在同一时间试图对该数据执行读取或写入操作的线程数。
* 此锁最多支持 65535 个递归写入锁和 65535 个读取锁。试图超出这些限制将导致锁方法抛出 Error。
第1节：实例
package com.mcc.core.test.thread;import com.mcc.core.concurrent.ExecutorServiceUtils;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
* ReadWriteLock读写锁测试
*
*
* @author menergy
* DateTime: 13-12-31 上午11:26
*/
public class ReadWriteLockTest {
public static void main(String args[]){
ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
final Lock readLock = readWriteLock.readLock();
final Lock writeLock = readWriteLock.writeLock();
ExecutorService executorServiceMain = ExecutorServiceUtils.getExecutor("Main", 10);
final ExecutorService executorService = ExecutorServiceUtils.getExecutor("test", 10);
executorServiceMain.execute(new Runnable() {
@Override
public void run() {
//10个读线程
for(int i = 0; i < 10; i++){
final int readId = i;
executorService.execute(new Runnable() {
@Override
public void run() {
readLock.lock();
try {
System.out.println("线程" + readId +"开始读");
// 读处理
TimeUnit.MILLISECONDS.sleep(300);
System.out.println("线程" + readId +"读完成");
}catch (InterruptedException e){
e.printStackTrace();
}finally {
readLock.unlock();
}
}
});
}
}
});
executorServiceMain.execute(ne