java高级工程师--------多线程并发

线程池（java5中）

ExecutorService threadPool =Executors.newFixedThreadPool(3);//创建固定大小的线程池

ExecutorService threadPool=Executors.newCachedThreadPool();//创建缓存线程池，动态变化线程数量，一段时间之后销毁未使用的线程

ExecutorService threadPool=Executors.newSingleThreadExecutor();//创建单一线程，当线程死掉之后立马启动替补线程

lock condition 实现线程同步通信

lock类似于synchronized,但是比synchronize更加面向对象化

使用： Lock lock=new Reentranlock();

lock.lock(); lock.unlock();

读写锁的应用ReadWriteLock rwl=new ReentrantReadWriteLock();

缓存系统的实现-------

public class CacheDemo{

private Map<String,Object> cache=new HashMap<String,Object>();

private ReadWriteLock rwl=new ReentrantReadWriteLock();

public Object getData(String key){

rwl.readLock().lock(); //读之间可以不挂锁，但是怕是内存中没值，就得读数据库然后往缓存中写数据，所以挂上



Object value= null;



try{

value=cache.get(key);

if(value==null){

rwl.readLock().unlock();//如果没有数据就得进行写操作，就得将读解锁，开启写锁

rwl.writeLock().lock();

try{

if(value==null){//多个线程都走到rml.writeLock().lock()时，一个线程写入成功之后，则此时后面线程再到这一步时的判断缓存中是否有数据



value="aaa";

}



}

finally{

rwl.writeLock().lock();



}

rwl.readLock().lock();



}



}



finally{

rwl.readLock().unlock();

}

return value;



}

}

Condition线程间通信

Lock lock=new Reentranlock();

Condition condition=lock.newCondition();

condition.await();

condition.signal();

应用实例：三个线程相互执行，线程一执行10次进入等待线程二开始执行，线程二执行50次进入等待线程三开始执行，线程三执行100次进入等待线程一开始执行，依次交替执行50次。

主要思想，建一个类，初始化三个condition对象，分别用于三个线程的等待、唤醒，写三个对应的方法根据每个线程实现处理逻辑

semaphore信号灯

Semaphore semaphore = new Semaphore(3);

应用实例：现有10个人等待上厕所，卫生间只有5个厕所位，一次性最多进5个人，当有人出来才能再进，用信号灯实现

CyclicBarrier 和CountDownLatch和Exchanger同步工具
阻塞队列的应用 数据的集合 先进先出 阻塞队列 和非阻塞队列 和固定长度的和非固定长度的



BlockingQueue<String> queue = new ArrayBlockingQueue(16);//阻塞队列放16个数据

同步集合类得应用

CopyOnWriteArrayList keys=new CopyOnWriteArrayList();//解决集合读的时候不能写的操作问题

线程面试题

空中网4k/5k月薪挑选大四实习生的线程题

两年前，我们一个大四的学员去应聘空中网的实习生职位，空中网只给他出了三道线程题，拿回家做两天后再去给经理讲解，如果前两题做好了给4k月薪，第三道题也做出来的话就给5k的月薪。这样的实习薪水和招聘要求，不需要有工作经验的限制，纯粹是技术功底的比拼和考核，而不像许多其他公司非要招两年工作经验的人，逼得那些刚毕业和未毕业的大学生不得不去撒谎，不得不去做假简历，甚至假毕业证！所以，空中网的这份工作对未毕业的大学生来说，还是很有吸引力的。这个学生是否入职空中网，大家去猜吧，免得有人看不顺眼而叫骂，呵呵！

第一题：现有的程序代码模拟产生了16个日志对象，并且需要运行16秒才能打印完这些日志，请在程序中增加4个线程去调用parseLog()方法来分头打印这16个日志对象，程序只需要运行4秒即可打印完这些日志对象。原始代码如下：

package read;

public class Test {

public static void main(String[] args){

System.out.println("begin:"+(System.currentTimeMillis()/1000));

/*模拟处理16行日志，下面的代码产生了16个日志对象，当前代码需要运行16秒才能打印完这些日志。

修改程序代码，开四个线程让这16个对象在4秒钟打完。

*/

for(int i=0;i<16;i++){ //这行代码不能改动

final String log = ""+(i+1);//这行代码不能改动

{

Test.parseLog(log);

}

}

}

//parseLog方法内部的代码不能改动

public static void parseLog(String log){

System.out.println(log+":"+(System.currentTimeMillis()/1000));

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

第二题：现成程序中的Test类中的代码在不断地产生数据，然后交给TestDo.doSome()方法去处理，就好像生产者在不断地产生数据，消费者在不断消费数据。请将程序改造成有10个线程来消费生成者产生的数据，这些消费者都调用TestDo.doSome()方法去进行处理，故每个消费者都需要一秒才能处理完，程序应保证这些消费者线程依次有序地消费数据，只有上一个消费者消费完后，下一个消费者才能消费数据，下一个消费者是谁都可以，但要保证这些消费者线程拿到的数据是有顺序的。原始代码如下：

package queue;

public class Test {

public static void main(String[] args) {

System.out.println("begin:"+(System.currentTimeMillis()/1000));

for(int i=0;i<10;i++){ //这行不能改动

String input = i+""; //这行不能改动

String output = TestDo.doSome(input);

System.out.println(Thread.currentThread().getName()+ ":" + output);

}

}

}

//不能改动此TestDo类

class TestDo {

public static String doSome(String input){

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

String output = input + ":"+ (System.currentTimeMillis() / 1000);

return output;

}

}

第三题：现有程序同时启动了4个线程去调用TestDo.doSome(key, value)方法，由于TestDo.doSome(key, value)方法内的代码是先暂停1秒，然后再输出以秒为单位的当前时间值，所以，会打印出4个相同的时间值，如下所示：

4:4:1258199615

1:1:1258199615

3:3:1258199615

1:2:1258199615

请修改代码，如果有几个线程调用TestDo.doSome(key, value)方法时，传递进去的key相等（equals比较为true），则这几个线程应互斥排队输出结果，即当有两个线程的key都是"1"时，它们中的一个要比另外其他线程晚1秒输出结果，如下所示：

4:4:1258199615

1:1:1258199615

3:3:1258199615

1:2:1258199616

总之，当每个线程中指定的key相等时，这些相等key的线程应每隔一秒依次输出时间值（要用互斥），如果key不同，则并行执行（相互之间不互斥）。原始代码如下：

package syn;

//不能改动此Test类

public class Test extends Thread{

private TestDo testDo;

private String key;

private String value;

public Test(String key,String key2,String value){

this.testDo = TestDo.getInstance();

/*常量"1"和"1"是同一个对象，下面这行代码就是要用"1"+""的方式产生新的对象，

以实现内容没有改变，仍然相等（都还为"1"），但对象却不再是同一个的效果*/

this.key = key+key2;

this.value = value;

}

public static void main(String[] args) throws InterruptedException{

Test a = new Test("1","","1");

Test b = new Test("1","","2");

Test c = new Test("3","","3");

Test d = new Test("4","","4");

System.out.println("begin:"+(System.currentTimeMillis()/1000));

a.start();

b.start();

c.start();

d.start();

}

public void run(){

testDo.doSome(key, value);

}

}

class TestDo {

private TestDo() {}

private static TestDo _instance = new TestDo();

public static TestDo getInstance() {

return _instance;

}

public void doSome(Object key, String value) {

// 以大括号内的是需要局部同步的代码，不能改动!

{

try {

Thread.sleep(1000);

System.out.println(key+":"+value + ":"

+ (System.currentTimeMillis() / 1000));

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}

有兴趣的网友可以努力做做这些题，我不久将公布我的解答和相应的讲解视频。

大家只要将上面任何一题的完整代码复制到eclipse中的某个工程的src目录下，就可以自动生成包名和文件名，运行该程序就可以观察到程序修改前的运行效果。