黑马程序员--高新技术之多线程

------- android培训、java培训、期待与您交流！ ----------

回顾一下至今为止接触的所有的java面试题，大概可以分为两部分：一部分是，对于一些关于java基础的某个知识点的理解，
比如说说明一下面向对象的思想，类的加载机制等，另外一部分也是比较实际比较棘手的一部分，就是给你一个项目，让你回去做，
而这些项目的实现大都用到了java多线程技术，比如说张老师所讲的两个7k面试题，交通灯和银行调度系统，都是借助了多线程的技术，
所以个人感觉java多线程这部分的内容还是很重要的，至少对于解决面试来说是重要的。所以这篇学习日记记录的是jdk1.5以后出现的
关于java多线程的新技术。

一、多线程技术
线程池的基本思想还是一种对象池的思想，开辟一块内存空间，里面存放了众多（未死亡）的线程，池中线程执行调度由池管理器来处理。
当有线程任务时，从池中取一个，执行完成后线程对象归池，这样可以避免反复创建线程对象所带来的性能开销，节省了系统的资源。
在线程池的编程模式下，任务是提交给整个线程池，而不是直接交给某个线程，线程池在拿到任务后，它就在内部找有无空闲的线程，
再把任务交给内部某个空闲的线程，这就是封装。记住，任务是提交给整个线程池，一个线程同时只能执行一个任务，但可以同时向一个线程池提交多个任务。
线程池的分类：
固定尺寸的线程池、可变尺寸连接池

jdk中对于线程池提供的api：
Executor接口：是用来执行Runnable任务的
方法：
execute(Runnable command)：执行Ruannable类型的任务

ExecutorService 接口 ExecutorService继承了Executor的方法，并提供了执行Callable任务和中止任务执行的服务
方法：
 void shutdown() --在完成已提交的任务后关闭服务，不再接受新任务 
 Future<T> submit(Runnable task)   --提交一个 Runnable 任务用于执行，并返回一个表示该任务的 Future。
 Future<T> submit(Callable<T> task) --提交一个返回值的任务用于执行，返回一个表示任务的未决结果的 Future。
 实现这个接口的类有：
 ThreadPoolExecutor --它使用可能的几个池线程之一执行每个提交的任务，通常使用 Executors 工厂方法配置。

 ScheduledExecutorService 接口，可安排在给定的延迟后运行或定期执行的命令（用作定时器）
 方法：
 ScheduledFuture<?> schedule(Runnable command,long delay,TimeUnit unit) --创建并执行在给定延迟后启用的一次性操作。
 ScheduledFuture<?> scheduleAtFixedRate(Runnable command,long initialDelay, long period,TimeUnit unit) 
--解读参数:
command - 要执行的任务
initialDelay - 首次执行的延迟时间
period - 连续执行之间的周期
unit - initialDelay 和 period 参数的时间单位 
实现类
 ScheduledThreadPoolExecutor  --继承ThreadPoolExecutor的ScheduledExecutorService接口实现，周期性任务调度的类实现。

callable(Runnable task): 将Runnable的任务转化成Callable的任务
newSingleThreadExecutor: 产生一个ExecutorService对象，这个对象只有一个线程可用来执行任务，若任务多于一个，任务将按先后顺序执行。
newCachedThreadPool(): 产生一个ExecutorService对象，这个对象带有一个线程池，线程池的大小会根据需要调整，线程执行完任务后返回线程池，供执行下一次任务使用。
newFixedThreadPool(int poolSize)：产生一个ExecutorService对象，这个对象带有一个大小为poolSize的线程池，若任务数量大于poolSize，任务会被放在一个queue里顺序执行。
newSingleThreadScheduledExecutor：产生一个ScheduledExecutorService对象，这个对象的线程池大小为1，若任务多于一个，任务将按先后顺序执行。
newScheduledThreadPool(int poolSize): 产生一个ScheduledExecutorService对象，这个对象的线程池大小为poolSize，若任务数量大于poolSize，任务会在一个queue里等待执行

代码实现：
package com.itheima.newthread;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ThreadPoolTest {

	public static void main(String[] args) {
		//用3个大小的固定线程池去执行10个内部循环10次就结束的任务，线程池内只有3个线程在执行，
		//固定线程池下的其他任务一直再等待
		//ExecutorService service = Executors.newFixedThreadPool(3);
		
		//有多少任务就分配多少个线程
		ExecutorService service = Executors.newCachedThreadPool();
		for(int i=1;i<=10;i++){
			final int sequence = i;
			//仔细品味runnable对象放到循环里面和外面的区别，为了让每个对象有自己独立的编号			
			service.execute(new Runnable(){
				public void run() {
					try{Thread.sleep(200);}catch(Exception e){}
					for(int j=1;j<=5;j++){
						System.out.println(Thread.currentThread().getName() + "   is serving " 
								+ sequence + " task:" + "loop of " + j);
					}
				}
			});
		}
		/*
		用下面这句代码来说明上面的代码是在提交任务，并且所有的任务都已经提交了，但任务是什么时候执行的，则是由线程池调度的！
		*/
		System.out.println("all task have committed!");	
		//注意与service.shutdownNow()的区别。
		service.shutdown();
		
		/* 测试线程池的定时器*/
		//定义一个定时器的线程池，线程池的大小是1，即只有池内只有一个定时器
		ScheduledExecutorService scheduledService = Executors.newScheduledThreadPool(1);
		//给定时器线程池分配的任务
		scheduledService.scheduleAtFixedRate(
				new Runnable(){
					public void run() {
						System.out.println("bomb!!!");
					}}, 
				5, 
				1,
				TimeUnit.SECONDS);
	}
	
}

二、带有返回结果的线程
jdk中的api的支持：


Callable 接口 -- Callable 接口类似于 Runnable，两者都是为那些其实例可能被另一个线程执行的类设计的。
但是 Runnable 不会返回结果，并且无法抛出经过检查的异常。
方法：
 V call() 计算结果，如果无法计算结果，则抛出一个异常 。相似于run（）方法

 Future 接口  -- 表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并获取计算的结果。
 计算完成后只能使用 get 方法来获取结果，如有必要，计算完成前可以阻塞此方法。取消则由 cancel 方法来执行。
 方法：
 V get(long timeout, TimeUnit unit) --如有必要，最多等待为使计算完成所给定的时间之后，获取其结果（如果结果可用）。 

FutureTask 类 ：是 Future 的一个实现，Future 可实现 Runnable，所以可通过 Executor 来执行。

代码实现：
 

package com.itheima.newthread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class ReturnThread {
	public static void main(String[] args) throws Exception {
		ExecutorService th = Executors.newSingleThreadExecutor();
		Future<String> future = th.submit(new Callable<String>() {

			@Override
			public String call() throws Exception {
				// 可以查询数据库中的内容返回
				return "data from ds";
			}
		});
		
		//获取线程得返回值
		String str = future.get();
		//打印结果
		System.out.println("thread returned data:"+str);
	}
}

三、jdk1.5对锁的新实现
在说明这个问题之前，首先我想说一下在5.0之前锁定的锁定的功能是由Synchronized关键字来实现的，这样做存在几个问题：
每次只能对一个对象进行锁定。若需要锁定多个对象，编程就比较麻烦，一不小心就会出现死锁现象。
如果线程因拿不到锁定而进入等待状况，是没有办法将其打断的。
而jdk1.5对锁的实现却很好的避免这个问题：


jdk中对新锁的api支持：
Lock 接口 --  实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。此实现允许更灵活的结构，可以具有差别很大的属性，可以支持多个相关的 Condition 对象。
方法：
lock():  --请求锁定，如果锁已被别的线程锁定，调用此方法的线程被阻断进入等待状态。
unlock()：取消锁定，需要注意的是Lock不会自动取消，编程时必须手动解锁。

实现类：ReentrantLock 无特别的方法
ReadWriteLock 接口：
为了提高效率有些共享资源允许同时进行多个读的操作，但只允许一个写的操作，比如一个文件，只要其内容不变可以让多个线程同时读，不必做排他的锁定，
排他的锁定只有在写的时候需要，以保证别的线程不会看到数据不完整的文件。ReadWriteLock可满足这种需要。ReadWriteLock内置两个Lock，一个是读的Lock，一个是写的Lock。
多个线程可同时得到读的Lock，但只有一个线程能得到写的Lock，而且写的Lock被锁定后，任何线程都不能得到Lock。ReadWriteLock提供的方法有：
readLock(): 返回一个读的lock
writeLock(): 返回一个写的lock, 此lock是排他的。

Condition 接口：
有时候线程取得lock后需要在一定条件下才能做某些工作，比如说经典的Producer和Consumer问题，Consumer必须在篮子里有苹果的时候才能吃苹果，否则它必须暂时放弃对篮子的锁定，等到Producer往篮子里放了苹果后再去拿来吃。而Producer必须等到篮子空了才能往里放苹果，否则它也需要暂时解锁等Consumer把苹果吃了才能往篮子里放苹果。
在Java 5.0以前，这种功能是由Object类的wait(), notify()和notifyAll()等方法实现的，在5.0里面，这些功能集中到了Condition这个接口来实现，Condition提供以下方法：
await()：使调用此方法的线程放弃锁定，进入睡眠直到被打断或被唤醒。
signal(): 唤醒一个等待的线程
signalAll()：唤醒所有等待的线程

代码实现：

package com.itheima.newthread;
import java.util.Random;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockTest {
	public static void main(String[] args) {
		//将对象声明为final的形式，以便于在匿名内部中调用（即后面的new Thread（）{}）
		final Queue queue = new Queue();
		//循环产生6个线程，用于读写数据
		for(int i=0;i<3;i++)
		{
			new Thread(){
				public void run(){
					while(true){
						queue.get();						
					}
				}
				
			}.start();

			new Thread(){
				public void run(){
					while(true){
						queue.put(new Random().nextInt(10000));
					}
				}			
				
			}.start();
		}
		
	}
}

//将线程的共享数据和相关的操作封装到类中
class Queue{
	//共享数据，只能有一个线程能写该数据，但可以有多个线程同时读该数据。
	private Object data = null;
	//定义读写锁
	ReadWriteLock rwl = new ReentrantReadWriteLock();
	//读数据的方法
	public void get(){
		rwl.readLock().lock();
		try {
			System.out.println(Thread.currentThread().getName() + " be ready to read data!");
			//随机休眠
			Thread.sleep((long)(Math.random()*1000));
			System.out.println(Thread.currentThread().getName() + "have read data :" + data);			
		} catch (InterruptedException e) {
			e.printStackTrace();
		}finally{
			//将关闭锁的语句放入到finally语句块中，是因为上面的try语句块中可能会出现异常而导致不能解锁
			rwl.readLock().unlock();
		}
	}
	
	public void put(Object data){
		//写数据的方法
		rwl.writeLock().lock();
		try {
			System.out.println(Thread.currentThread().getName() + " be ready to write data!");					
			Thread.sleep((long)(Math.random()*1000));
			this.data = data;		
			System.out.println(Thread.currentThread().getName() + " have write data: " + data);					
		} catch (InterruptedException e) {
			e.printStackTrace();
		}finally{
			rwl.writeLock().unlock();
		}
		
	
	}
}

下面在给出一个缓存系统设计的代码

package com.itheima.newthread;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class CacheDemo {
	//定义一个map集合用于存储需要缓存的数据
	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){
						value = "aaaa";//实际失去queryDB();
					}
				}finally{
					rwl.writeLock().unlock();
				}
				rwl.readLock().lock();
			}
		}finally{
			rwl.readLock().unlock();
		}
		return value;
	}
}

新的锁的总结：
Lock比传统线程模型中的synchronized方式更加面向对象，与生活中的锁类似，锁本身也应该是一个对象。
两个线程执行的代码片段要实现同步互斥的效果，它们必须用同一个Lock对象。
读写锁：分为读锁和写锁，多个读锁不互斥，读锁与写锁互斥，这是由jvm自己控制的，你只要上好相应的锁即可。如果你的代码只读数据，
可以很多人同时读，但不能同时写，那就上读锁；如果你的代码修改数据，只能有一个人在写，且不能同时读取，那就上写锁。总之，读的时候上读锁，写的时候上写锁！
在等待 Condition 时，允许发生“虚假唤醒”，这通常作为对基础平台语义的让步。对于大多数应用程序，这带来的实际影响很小，
因为 Condition 应该总是在一个循环中被等待，并测试正被等待的状态声明。某个实现可以随意移除可能的虚假唤醒，
但建议应用程序程序员总是假定这些虚假唤醒可能发生，因此总是在一个循环中等待。
一个锁内部可以有多个Condition，即有多路等待和通知，可以参看jdk1.5提供的Lock与Condition实现的可阻塞队列的应用案例，
从中除了要体味算法，还要体味面向对象的封装。在传统的线程机制中一个监视器对象上只能有一路等待和通知，要想实现多路等待和通知，
必须嵌套使用多个同步监视器对象。（如果只用一个Condition，两个放的都在等，一旦一个放的进去了，那么它通知可能会导致另一个放接着往下走。）

四、接下来是关于java多线程的几个工具类
Semaphore 类  --可以维护当前访问自身的线程个数，并提供了同步机制。使用Semaphore可以控制同时访问资源的线程个数，
构造方法：
Semaphore(int permits) --创建具有给定的许可数和非公平的公平设置的 Semaphore
方法：
void acquire() --从此信号量获取一个许可，在提供一个许可前一直将线程阻塞，否则线程被中断 
 void release()  --释放一个许可，将其返回给信号量。 

 简单的代码实现（主要演示其使用）：

 package com.itheima.newthread;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

public class SemaphoreTest {
	public static void main(String[] args) {
		ExecutorService service = Executors.newCachedThreadPool();
		final  Semaphore sp = new Semaphore(3);
		for(int i=0;i<10;i++){
			Runnable runnable = new Runnable(){
					public void run(){
					try {
						//记录有一个线程来到，阻塞
						sp.acquire();
					} catch (InterruptedException e1) {
						e1.printStackTrace();
					}
					System.out.println("线程" + Thread.currentThread().getName() + 
							"进入，当前已有" + (3-sp.availablePermits()) + "个并发");
					try {
						Thread.sleep((long)(Math.random()*10000));
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println("线程" + Thread.currentThread().getName() + 
							"即将离开");					
					sp.release();
					//下面代码有时候执行不准确，因为其没有和上面的代码合成原子单元
					System.out.println("线程" + Thread.currentThread().getName() + 
							"已离开，当前已有" + (3-sp.availablePermits()) + "个并发");					
				}
			};
			service.execute(runnable);			
		}
	}

}

CountDownLatch 类： --CountDownLatch是个计数器，它有一个初始数，等待这个计数器的线程必须等到计数器倒数到零时才可继续
构造方法：
CountDownLatch(int count) --构造一个用给定计数初始化的 CountDownLatch
方法：
void await()：使调用此方法的线程阻断进入等待
void countDown(): 倒计数，将计数值减1
long getCount(): 得到当前的计数值

简单代码实现：
package com.itheima.newthread;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CyclicBarrierTest {

	public static void main(String[] args) {
		ExecutorService service = Executors.newCachedThreadPool();
		final  CyclicBarrier cb = new CyclicBarrier(3);
		for(int i=0;i<3;i++){
			Runnable runnable = new Runnable(){
					public void run(){
					try {
						Thread.sleep((long)(Math.random()*10000));	
						System.out.println("线程" + Thread.currentThread().getName() + 
								"即将到达集合地点1，当前已有" + (cb.getNumberWaiting()+1) + "个已经到达，" + (cb.getNumberWaiting()==2?"都到齐了，继续走啊":"正在等候"));						
						cb.await();
						
						Thread.sleep((long)(Math.random()*10000));	
						System.out.println("线程" + Thread.currentThread().getName() + 
								"即将到达集合地点2，当前已有" + (cb.getNumberWaiting()+1) + "个已经到达，" + (cb.getNumberWaiting()==2?"都到齐了，继续走啊":"正在等候"));
						cb.await();	
						Thread.sleep((long)(Math.random()*10000));	
						System.out.println("线程" + Thread.currentThread().getName() + 
								"即将到达集合地点3，当前已有" + (cb.getNumberWaiting() + 1) + "个已经到达，" + (cb.getNumberWaiting()==2?"都到齐了，继续走啊":"正在等候"));						
						cb.await();						
					} catch (Exception e) {
						e.printStackTrace();
					}				
				}
			};
			service.execute(runnable);
		}
		service.shutdown();
	}
}

Exchanger 类：让两个线程可以互换信息。用于实现两个人之间的数据交换，每个人在完成一定的事务后想与对方交换数据，第一个先拿出数据的人将一直等待第二个人拿着数据到来时，才能彼此交换数据。
构造方法：
Exchanger() --创建一个新的 Exchanger
方法：V exchange(V x) 等待另一个线程到达此交换点（除非当前线程被中断），然后将给定的对象传送给该线程，并接收该线程的对象。

代码实现：
package com.itheima.newthread;
import java.util.concurrent.Exchanger;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ExchangerTest {

	public static void main(String[] args) {
		ExecutorService service = Executors.newCachedThreadPool();
		final Exchanger exchanger = new Exchanger();
		service.execute(new Runnable(){
			public void run() {
				try {				

					String data1 = "zxx";
					System.out.println("线程" + Thread.currentThread().getName() + 
					"正在把数据" + data1 +"换出去");
					Thread.sleep((long)(Math.random()*10000));
					String data2 = (String)exchanger.exchange(data1);
					System.out.println("线程" + Thread.currentThread().getName() + 
					"换回的数据为" + data2);
				}catch(Exception e){
					
				}
			}	
		});
		service.execute(new Runnable(){
			public void run() {
				try {				

					String data1 = "lhm";
					System.out.println("线程" + Thread.currentThread().getName() + 
					"正在把数据" + data1 +"换出去");
					Thread.sleep((long)(Math.random()*10000));					
					String data2 = (String)exchanger.exchange(data1);
					System.out.println("线程" + Thread.currentThread().getName() + 
					"换回的数据为" + data2);
				}catch(Exception e){
					
				}				
			}	
		});		
	}
}

阻塞队列：
阻塞队列的概念是，一个指定长度的队列，如果队列满了，添加新元素的操作会被阻塞等待，
直到有空位为止。同样，当队列为空时候，请求队列元素的操作同样会阻塞等待，直到有可用元素为止。


BlockingQueue 接口，阻塞队列的顶层接口
方法：
void put(E e) --将指定元素插入此队列中，将等待可用的空间 阻塞式的
 E take() -- 获取并移除此队列的头部，在元素变得可用之前一直等待 ，阻塞式的


 实现类有：
 ArrayBlockingQueue， LinkedBlockingDeque, LinkedBlockingQueue, PriorityBlockingQueue, SynchronousQueue

代码实现：
 package com.itheima.newthread;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class BlockingQueueTest {
	public static void main(String[] args) {
		final BlockingQueue queue = new ArrayBlockingQueue(3);
		for(int i=0;i<2;i++){
			new Thread(){
				public void run(){
					while(true){
						try {
							Thread.sleep((long)(Math.random()*1000));
							System.out.println(Thread.currentThread().getName() + "准备放数据!");							
							queue.put(1);
							System.out.println(Thread.currentThread().getName() + "已经放了数据，" + 							
										"队列目前有" + queue.size() + "个数据");
						} catch (InterruptedException e) {
							e.printStackTrace();
						}

					}
				}
				
			}.start();
		}
		
		new Thread(){
			public void run(){
				while(true){
					try {
						//将此处的睡眠时间分别改为100和1000，观察运行结果
						Thread.sleep(1000);
						System.out.println(Thread.currentThread().getName() + "准备取数据!");
						queue.take();
						System.out.println(Thread.currentThread().getName() + "已经取走数据，" + 							
								"队列目前有" + queue.size() + "个数据");					
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
			
		}.start();			
	}
}

同步集合：
传统集合类在并发访问时的问题说明，见附件
传统方式下用Collections工具类提供的synchronizedCollection方法来获得同步集合，分析该方法的实现源码。
传统方式下的Collection在迭代集合时，不允许对集合进行修改。
用空中网面试的同步级线程题进行演示
根据AbstractList的checkForComodification方法的源码，分析产生ConcurrentModificationException异常的原因。
Java5中提供了如下一些同步集合类：
通过看java.util.concurrent包下的介绍可以知道有哪些并发集合
ConcurrentHashMap
CopyOnWriteArrayList
CopyOnWriteArraySet


ps：终于完了，java多线程的新技术和我的最后一篇学习日记，说句心里话，通过写这10篇的博客，
我已经深感到程序员的不容易与辛苦。有人说程序员工资高，但那却是我们艰苦拼搏的结果，我们受得起！！
继续奋斗吧！！