一.线程的实现方式

　　继承Thread

　　实现Runnable接口

　　二.线程的状态

　　1.New(新生线程)

　　当你new一个Thread，newThread(r),这时处于线程的新生状态，此时程序还没有真正的运行。

　　2.Runnable(可运行的)

　　当启动start()方法时，此时线程处于可运行状态，不一定运行之中，这取决与线程是否得到CPU的运行时间片。事实上，一个线程并不是一直处于运行状态，偶尔需要被中断，让其他线程有运行的机会。

　　3.Blocked(被阻塞)

　　当发生以下情况被阻塞

　　-线程调用sleep方法处于睡眠状态

　　-线程进行I/O操作被中断，等待I/O操作完成。

　　-线程试图取得一个锁对象，而此时这个所对象被其他线程持有，等待锁被释放

　　-线程在等待某个触发条件

　　-有人调用了线程的suspend方法，除非等待别人调用resume方法将这个线程挂起。这个方法已经过时，而你不能再你的代码中调用这个方法。

　　4.Dead(死亡线程)

　　-run方法运行完毕导致线程正常死亡

　　-因为一个未捕获的异常使得线程死亡

　　三.同步

　　当多个线程共享数据的时候，需要注意对数据进行同步保护。可以使用synchronized关键字，您可以将synchronized这种方式看做一个隐式的锁，然后这个隐士的锁只能关联一个条件对象。JDK5.0使用锁对象的概念。

Java代码
  1.  private Lock myLock = new ReenTrantLock();  
  2.  public void sysnMethod(){  
  3.     myLock.lock();          //获取锁对象,一旦获得锁，其他线程进入时候被阻塞，等待此线程释放  
  4.    try{  
  5.    }catch(){  
  6.    }finally{  
  7.       myLock.unLock();  
  8.    }  
  9. }  

　　每个对象拥有自己的ReenTrantLock对象，不同对象有不同的锁。

　　2.条件对象

　　当某些线程具备某个条件时才能运行。

Java代码
  1. private Lock myLock = new ReenTrantLock();  
  2. private Condition hasMoreMoney;  
  3. hasMoreMoney = myLock.newCondition();//myLock获取一个条件对象  
  4.   
  5. public void transfermoney(){  
  6.    myLock.lock();  //获取锁  
  7.    try{  
  8.        if(nowMoney<tranferMoney){  
  9.          hasMoreMoney.await(); //如果不满足条件，条件对象阻塞此线程，并且释放锁对象，使得此对象进入等待条件集中，等待条件满足。  
  10.        }  
  11.        hasMoreMoney.signalAll();  //因为线程进入等待条件集中，即使获得锁，也不能被激活，他需要其他线程唤醒他，signal()//随机唤醒等待条件集中线程的任一线程  
  12.    }catch(){  
  13.    }finally{  
  14.       myLock.unLock();  
  15.    }  
  16. }  

　　一旦线程被唤醒后，并满足条件对象，继续运行程序，而不是重新运行程序。

　　隐式锁和条件缺点：

　　1.您不能中断一个试图获得锁的线程

　　2.您不能堆试图获得锁的线程设置超时

　　3.隐式锁的条件一个显得不够用

　　4.虚拟机的加锁机制不能很好映射到硬件的加锁机制上

　　3.常用方法解释

　　nitifyAll()----------解除在该对象上调用wait()的线程的阻塞，这个方法只能再同步方法或者同步块中使用，如果当前线程不是锁的持有者，抛出异常。

　　notify()------------随机解除该对象因调用wait()的任一线程的阻塞。

　　wait()-------------导致线程进入等待状态直到被通知。这个方法只能再同步方法或者同步块中使用。此时放弃对象的锁。

　　四.监视器

　　1.监视器的特性

　　2.每个监视器类的对象都有一个相关的锁

　　3.这个锁负责对所有方法加锁

　　4.这个锁可以有任意个关联条件

　　5.Volatile域------为一个同步机制的实例域提供了免锁机制。允许多个线程并发更新。访问一个Volatile变量比访问一般变量要慢，因为它是线程安全的。

　　在以下三个条件下，对一个域的访问时安全的。

　　-域是vilatile的

　　-域是final，并且在构造器调用完成后访问

　　-对域的访问有锁保护

　　五.死锁

　　六.公平锁

　　公平锁会优待那些等待时间较长的线程，但是它会降低了性能。也不能做到真正的公平。

　　七.锁测试和超时

Java代码
  1. if(myLock.tryLock()){  //测试能否获得锁，获得返回TRUE，否则false  
  2.   try{  
  3.   }catch(){  
  4.   }finally{  
  5.     myLock.unLock();  
  6.   }  
  7. }else{  
  8.    //做别的事情  
  9. }  

　　可以myLock.teyLock(100,TimeUnit.MILLSECONDS) //设置超时时间

　　八.读/写锁

　　读/写锁的必要步骤

　　1.创建一个ReentrantReadWriteLock对象

Java代码
  1. ReentrantReadWriteLock rw = new ReentrantReadWriteLock();  

　　2.抽取读锁和写锁

Java代码
  1. Lock readLock = rw.readLock();  
  2. Lock writeLock = rw.writeLock();  

　　3.对读取得线程加读锁

Java代码
  1. public void getAllMoney{  
  2. readLock.lock();  
  3.  try{  
  4.   ......  
  5.  }finally{  
  6.    readLock.unLock();  
  7.  }  
  8. }  

　　4.对写数据的线程加写锁

Java代码
  1. public void transfer(){  
  2. writeLock .lock();  
  3.  try{  
  4.   ......  
  5.  }finally{  
  6.    writeLock .unLock();  
  7.  }  
  8. }  

　　九.stop和suspend方法为什么弃用

　　stop方法会破坏对象，当一个线程获得一个锁对象时，取款后，但是被stop，但是没有存入，最后终止了，那总款不正确，suspend不会破坏对象，但是很容易导致死锁，因为suspend挂起一个拥有锁的线程，它不会释放锁，而等待别人resume，这样，加入别人没有resume，而另外一个线程正在试图得到锁而被挂起，最后死锁了。

　　十.阻塞队列

　　相信大家对队列都很熟悉，队列抱着先进先出的原则。

　　BlockingQueue的操作方法

　　add 向队列添加一个元素 队列满，抛出一个异常

　　remove 删除一个队列元素 队列为空，抛出一个异常 element 返回队列头部元素 队列为空，抛出一个异常

　　offer 添加元素，返回true 如果队列满，返回false

　　poll 删除并返回头部元素，返回true 队列空，返回null peek 返回头部元素 队列空，返回null

　　put 添加一个元素 队列满，阻塞

　　take 获取并移除此队列的头部 队列空，阻塞

　　有一个经典的例子来说明阻塞队列：

Java代码
  1. package thread.queue;  
  2.   
  3. import java.io.File;  
  4. import java.util.concurrent.BlockingQueue;  
  5.   
  6. import javax.management.Query;  
  7.   
  8. public class FileEnumerationTask implements Runnable{  
  9.     private BlockingQueue<File> queue;  
  10.     public static File DUMMY = new File("");  
  11.     private File startingDirectory;  
  12.   
  13.     public FileEnumerationTask(BlockingQueue<File> queue, File startingDirectory) {  
  14.         super();  
  15.         this.queue = queue;  
  16.         this.startingDirectory = startingDirectory;  
  17.     }  
  18.   
  19.     public void enumrate(File directory) throws InterruptedException{  
  20.         File[] files=directory.listFiles();  
  21.         for(File f:files){  
  22.             if(f.isDirectory()){  
  23.                 enumrate(f);  
  24.             }else{  
  25.                 queue.put(f);  
  26.             }  
  27.         }  
  28.     }  
  29.     @Override  
  30.     public void run() {  
  31.         // TODO Auto-generated method stub  
  32.   
  33.         try {  
  34.             enumrate(startingDirectory);  
  35.             queue.put(DUMMY);  
  36.         } catch (InterruptedException e) {  
  37.             // TODO Auto-generated catch block  
  38.             e.printStackTrace();  
  39.         }  
  40.     }  
  41. }  
Java代码
  1. package thread.queue;  
  2.   
  3. import java.io.File;  
  4. import java.io.FileInputStream;  
  5. import java.io.FileNotFoundException;  
  6. import java.util.Scanner;  
  7. import java.util.concurrent.BlockingQueue;  
  8.   
  9. public class SearchTask implements Runnable {  
  10.     private BlockingQueue<File> queue;  
  11.     private String keyWord;  
  12.   
  13.   
  14.     public SearchTask(BlockingQueue<File> queue, String keyWord) {  
  15.         super();  
  16.         this.queue = queue;  
  17.         this.keyWord = keyWord;  
  18.     }  
  19.   
  20.     public void search(File file) throws FileNotFoundException{  
  21.         Scanner in  = new Scanner(new FileInputStream(file));  
  22.         int lineNumber=0;  
  23.         while(in.hasNextLine()){  
  24.             lineNumber++;  
  25.             String line = in.nextLine();  
  26.             if(line.contains(keyWord)){  
  27.                 System.out.printf("%s:%d:%s%n",file.getPath(),lineNumber,line);  
  28.             }  
  29.         }  
  30.         in.close();  
  31.     }  
  32.   
  33.     @Override  
  34.     public void run() {  
  35.         // TODO Auto-generated method stub  
  36.         boolean done =false;  
  37.         while(!done){  
  38.             try {  
  39.                 File file  = queue.take();  
  40.                 if(file==FileEnumerationTask.DUMMY){  
  41.                     queue.put(file);   //如果是结束文件符号，此线程退出循环，并将这个结束文件符号还交给队列  
  42.                     done=true;  
  43.                 }else{  
  44.                     try {  
  45.                         search(file);  
  46.                     } catch (FileNotFoundException e) {  
  47.                         // TODO Auto-generated catch block  
  48.                         e.printStackTrace();  
  49.                     }  
  50.                 }  
  51.             } catch (InterruptedException e) {  
  52.                 // TODO Auto-generated catch block  
  53.                 e.printStackTrace();  
  54.             }  
  55.         }  
  56.     }  
  57.   
  58. }  
Java代码
  1. package thread.queue;  
  2.   
  3. import java.io.File;  
  4. import java.util.Scanner;  
  5. import java.util.concurrent.ArrayBlockingQueue;  
  6. import java.util.concurrent.BlockingQueue;  
  7.   
  8. public class BlockingQueueTest {  
  9.   
  10.     /** 
  11.      * @param args 
  12.      */  
  13.     public static void main(String[] args) {  
  14.         // TODO Auto-generated method stub  
  15.     /*    Scanner in = new Scanner(System.in); 
  16.         System.out.println("Enter basic directory:"); 
  17.         String startingDirectory = in.nextLine(); 
  18.         System.out.println("Enter keyword:"); 
  19.         String keyword = in.nextLine();*/  
  20.   
  21.         String startingDirectory="D:/test";  
  22.         String keyword="chen";  
  23.         final int FILE_QUEUE_SIZE=10;  
  24.         final int SEARCH_THREADS=100;  
  25.         BlockingQueue<File> queues = new ArrayBlockingQueue<File>(FILE_QUEUE_SIZE) ;  
  26.         FileEnumerationTask fTask = new FileEnumerationTask(queues, new File(startingDirectory));  
  27.         new Thread(fTask).start();  
  28.         for(int i=1;i<=SEARCH_THREADS;i++){  
  29.             new Thread(new SearchTask(queues,keyword)).start();  
  30.         }  
  31.     }  
  32.   
  33. }  

　　十一.旧的线程安全集合

　　JDK1.0开始,Vector和Hashtable都是线程安全的集合，但是JDK1.2被弃用，代替的是ArrayList和HashMap。但是他们不是线程安全的。不过他们可以使用同步包装器(synchornization wapper)包装成线程安全的：

Java代码
  1. List synList = Collections.synchronizedList(new ArrayList<E>()); Map synMap = Collections.synchronizedMap(new HashMap());  

　　经过同步包装的Collection对象被一个锁保护，如果你想迭代这个Collection，需要使用同步块来保护。

　　十二.Callable和Future(对于这一块，个人理解也不是非常清楚)

　　Runnable封装的是异步运行的的任务，您可以把它想象成没有任何参数和返回值的异步方法。Callable和Runnable相似，但是它有参数类型和返回值，只有一个方法call()

Java代码
  1. interface Callable<V>{  
  2.     V call() throws Exception;  
  3. }  

　　Future对象保存异步计算的结果。Future对象的持有者在结果计算完毕后能得到它。

Java代码
  1. public interface Future<V>{  
  2.   
  3.   V get();                                        //被阻塞，直至计算完成。  
  4.   
  5.   V get(long timeout,Timeunit unit);     //如果在计算完成前超时，抛出异常，如果运行时线程被中断，抛中断异常，如果计算完成，返回结果。  
  6.   
  7.   void cancel(boolean myInterrupt);     //如果计算还没有开始，那么将永远不会开始，如果已经在计算之中，那么被中断  
  8.   
  9.   boolean isCancel();  
  10.   
  11.   boolean isDone();  
  12.   
  13. }  

　　十三.线程池

　　1.执行器(Executor)

　　下面有几种构建线程池的静态工厂方法：

　　--------------------------------------ExecutorService接口-----------------------------

　　newCachedThreadPool-------------------在需要的时候创建新线程，空闲的时候保存60秒

　　newFixedThreadPool---------------------池中保存一定数量的线程，空闲的时候也保存

　　newSingleThreadExecutor----------------只有一个线程的池，这个线程顺寻执行提交的任务

　　--------------------------------ScheduledExecutorService接口-----------------------

　　newScheduledThreadPool----------------为预定执行而构建的固定线程池

　　newSingleThreadScheduledThreadPool----为预定执行而构建的单线程的池

　　下面看一个例子来解释：

　　(1).为使用线程池的概念的核心代码(这个例子会产生很多子线程)

Java代码
  1. /**********************************/  
  2. MatchCounter mc = new MatchCounter(new File(directory), keyword); //一个实现了Callable的类，有个Call方法计算文件个数  
  3. FutureTask<Integer> task = new FutureTask<Integer>(mc); //最后结果存在FutureTask  
  4. Thread t = new Thread(task);  
  5. t.start();  

　　(2).使用线程池的概念

Java代码
  1. ExecutorService pool = Executors.newCachedThreadPool(); MatchCounter mc = new MatchCounter(new File(directory), keyword,pool); Future<Integer> task = pool.submit(mc);  

　　MatchCounter的代码如下：

Java代码
  1. package thread.threadpool;  
  2.   
  3. import java.io.File;  
  4. import java.io.FileInputStream;  
  5. import java.io.FileNotFoundException;  
  6. import java.util.ArrayList;  
  7. import java.util.Scanner;  
  8. import java.util.concurrent.Callable;  
  9. import java.util.concurrent.ExecutorService;  
  10. import java.util.concurrent.Future;  
  11. import java.util.concurrent.FutureTask;  
  12.   
  13. public class MatchCounter implements Callable<Integer> {  
  14.     private File directory;  
  15.     private String keyword;  
  16.     private ExecutorService pool;  
  17.     private int count;  
  18.   
  19.     public MatchCounter(File directory, String keyword,ExecutorService pool) {  
  20.         super();  
  21.         this.directory = directory;  
  22.         this.keyword = keyword;  
  23.         this.pool = pool;  
  24.     }  
  25.   
  26.   
  27.   
  28.     @Override  
  29.     public Integer call() throws Exception {  
  30.         // TODO Auto-generated method stub  
  31.         int count=0;  
  32.   
  33.         File[] files = directory.listFiles();  
  34.   
  35.         ArrayList<Future<Integer>> results = new ArrayList<Future<Integer>>();  
  36.   
  37.         for(File file:files){  
  38.             if(file.isDirectory()){  
  39.                 MatchCounter counter = new MatchCounter(file, keyword,pool);  
  40.             /*    FutureTask<Integer> task = new FutureTask<Integer>(counter); 
  41.                 results.add(task); 
  42.                 Thread t = new Thread(task); 
  43.                 t.start();*/  
  44.                 Future<Integer> result = pool.submit(counter);  
  45.                 results.add(result);  
  46.             }else{  
  47.                 if(search(file)){  
  48.                     count++;  
  49.                 }  
  50.             }  
  51.   
  52.             for(Future<Integer> f :results){  
  53.                 count+=f.get();  
  54.             }  
  55.         }  
  56.   
  57.         return count;  
  58.     }  
  59.   
  60.   
  61.     public boolean search(File file){  
  62.   
  63.         try {  
  64.             Scanner in = new Scanner(new FileInputStream(file));  
  65.             boolean founds= false;  
  66.             while(!founds&&in.hasNextLine()){  
  67.                 String line = in.nextLine();  
  68.                 if(line.contains(keyword)){  
  69.                     founds =true;  
  70.                 }  
  71.             }  
  72.             in.close();  
  73.             return founds;  
  74.         } catch (FileNotFoundException e) {  
  75.             // TODO Auto-generated catch block  
  76.             return false;  
  77.         }  
  78.     }  
  79. }  

　　那么，线程池所要做的事情如下：

　　(1).调用Executors的静态工厂方法newCachedThreadPool或者newFixedThreadPool。

　　(2).调用submit来提交一个Runnable或者Callable对象

　　(3).如果能够希望取消任务或者如果提交的是Callable对象，那么保存好返回的Future对象

　　(4).当不想再提交任何任务时调用shutdown

　　接着看看预定义执行接口的实现：

　　SchduledExecutorService具有为预定或重复执行任务而设计的方法，可以预定Runnable或者Callable预定只运行一次或者周期性运行。newScheduledThreadPool，newSingleThreadScheduledThreadPool返回的是SchduledExecutorService的对象。

　　ScheduledFuture schedule(Callable<V> callable, long delay, TimeUnit unit)----预定在给定的时间执行任务

　　scheduleAtFixedRate(Runnable command, long initialDelay, long period,TimeUnit unit)---

　　创建并执行一个在给定初始延迟后首次启用的定期操作，后续操作具有给定的周期；也就是将在 initialDelay 后开始执行，然后在 initialDelay+period 后执行，接着在 initialDelay + 2 * period 后执行，依此类推。如果任务的任何一个执行遇到异常，则后续执行都会被取消。否则，只能通过执行程序的取消或终止方法来终止该任务。如果此任务的任何一个执行要花费比其周期更长的时间，则将推迟后续执行，但不会同时执行。

　　scheduleWithFixedDelay(Runnable command,long initialDelay,long delay,TimeUnit unit)

　　创建并执行一个在给定初始延迟后首次启用的定期操作，随后，在每一次执行终止和下一次执行开始之间都存在给定的延迟。如果任务的任一执行遇到异常，就会取消后续执行。否则，只能通过执行程序的取消或终止方法来终止该任务。

　　十四.控制线程组(ExecutorCompletionService)

　　ExecutorService invokeAny(Collection<? extends Callable<T>> tasks)----执行给定的任务，如果某个任务已成功完成（也就是未抛出异常），则返回其结果。一旦正常或异常返回后，则取消尚未完成的任务。如果此操作正在进行时修改了给定的 collection，则此方法的结果是不确定的。

　　List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,long timeout,TimeUnit unit)

　　执行给定的任务，当所有任务完成时，返回保持任务状态和结果的 Future 列表。返回列表的所有元素的 Future.isDone() 为 true。注意，可以正常地或通过抛出异常来终止已完成 任务。如果正在进行此操作时修改了给定的 collection，则此方法的结果是不确定的。

　　缺点：如果有一个线程运行花很多的时间，你不得不去等待。

　　ExecutorCompletionService new ExecutorCompletionService(Executor e)

　　submit(Callable<V> task) ---------提交要执行的值返回任务，并返回表示挂起的任务结果的 Future。在完成时，可能会提取或轮询此任务。

　　submit(Runnable task,V result)----提交要执行的 Runnable 任务，并返回一个表示任务完成的 Future，可以提取或轮询此任务.

　　十五.障栅(CyclicBarrier)

　　当考虑大量线程分别计算不同部分时。所有部分计算完毕后，需要整合所有部分时，可以用到障栅。它的原理是，当某一个线程运行完它的部分时，就在障栅出等待，知道所有部分完成后，障栅结束，等待线程释放。继续运行。

Java代码
  1. CyclicBarrier barrier = new CyclicBarrier(nThread) // 参与运行的线程数    
  2. public void run(){    
  3.     doWork();    //每个线程都要做的工作    
  4.     barrier.await();    
  5. }

　　障栅是循环的，它可以在所有等待线程释放后被重用。

　　十六.倒计时门拴(CountDownLatch)

　　一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。

　　用给定的计数 初始化 CountDownLatch。由于调用了 countDown() 方法，所以在当前计数到达零之前，await 方法会一直受阻塞。之后，会释放所有等待的线程，await 的所有后续调用都将立即返回。这种现象只出现一次——计数无法被重置。如果需要重置计数，请考虑使用 CyclicBarrier。

　　CountDownLatch 是一个通用同步工具，它有很多用途。将计数 1 初始化的 CountDownLatch 用作一个简单的开/关锁存器，或入口：在通过调用 countDown() 的线程打开入口前，所有调用 await 的线程都一直在入口处等待。用 N 初始化的 CountDownLatch 可以使一个线程在 N 个线程完成某项操作之前一直等待，或者使其在某项操作完成 N 次之前一直等待。

　　CountDownLatch 的一个有用特性是，它不要求调用 countDown 方法的线程等到计数到达零时才继续，而在所有线程都能通过之前，它只是阻止任何线程继续通过一个 await。

　　另一种典型用法是，将一个问题分成 N 个部分，用执行每个部分并让锁存器倒计数的 Runnable 来描述每个部分，然后将所有 Runnable 加入到 Executor 队列。当所有的子部分完成后，协调线程就能够通过 await。（当线程必须用这种方法反复倒计数时，可改为使用 CyclicBarrier。）

　　倒计时门拴和障栅区别：

　　(1)不是所有线程都等到门拴打开为止

　　(2)门拴可以由外部事件打开

　　(3)倒计时门拴是一次性的，一旦计数到达0，不可重用

　　十七.交换器(Exchanger)

　　当两个线程工作一个一个数据缓冲区的两个实例上，可以使用交换器，一个线程向数据缓冲区注入数据，另一个线程读取数据，当完成后，它们相互交换缓冲。

　　十八.同步列(SynchronousQueue)

　　一种阻塞队列，其中每个插入操作必须等待另一个线程的对应移除操作 ，反之亦然。同步队列没有任何内部容量，甚至连一个队列的容量都没有。不能在同步队列上进行 peek，因为仅在试图要移除元素时，该元素才存在；除非另一个线程试图移除某个元素，否则也不能（使用任何方法）插入元素；也不能迭代队列，因为其中没有元素可用于迭代。队列的头 是尝试添加到队列中的首个已排队插入线程的元素；如果没有这样的已排队线程，则没有可用于移除的元素并且 poll() 将会返回 null。对于其他 Collection 方法（例如 contains），SynchronousQueue 作为一个空 collection。此队列不允许 null 元素。

　　十九.信号量(Semaphore)(不是很理解)

　　一个计数信号量。从概念上讲，信号量维护了一个许可集。如有必要，在许可可用前会阻塞每一个 acquire()，然后再获取该许可。每个 release() 添加一个许可，从而可能释放一个正在阻塞的获取者。但是，不使用实际的许可对象，Semaphore 只对可用许可的号码进行计数，并采取相应的行动。

除非特别注明，鸡啄米文章均为原创
转载请标明本文地址：http://www.jizhuomi.com/software/575.html
2016年5月20日
作者:鸡啄米 分类:软件开发 浏览: 评论:0