java多线程一览

• 线程概述:
  • 多线程的目的,不是提高程序的执行速度,而是提高程序的使用率(能抢到CPU的可能比较大). 因为线程是CPU调度的基本单位,所以,当一个程序的线程较多的时候就更容易抢到cpu的资源
  • 进程:
    • 运行中的程序,是系统进行资源分配和调度的独立单位
    • 每个进程都有他自己的内存空间和系统资源
  • 线程:
    • 是进程中的单个顺序控制流,是一条执行路径,是cpu调度的基本单位
    • 一个进程如果有多条执行路径,称:多线程
    • 一个进程如果只有一条执行路径,称:单线程
• 线程生命周期:
  • 
• java中线程概览: [ ps : 图来自郭朝:http://blog.csdn.net/smartbetter/article/details/51335165]
  • 
• 继承Thread类 和 实现Runnable:

 /**
 *继承Thread类 和 实现Runnable:
 *        1.后者解决了java单继承的局限性
         2.后者更适合多个相同的程序代码处理同一个资源的情况,将数据与代码有效分离,体现了java面向对象的思维
 *
 *有人说:
 *    前者是多个线程各自执行各自的任务,
 *    后者是多个线程处理相同的任务
 *
 *一般用后者的人居多,因为更灵活
 */

 // 继承Thread类
 class MyThread extends Thread{
     private static Object shareData; // 实现数据共享
     @Overwrite
     public void run(){
         System.out.println("当前线程是"+Thread.currentThread.getName());
     }
 }
 // 创建线程
 class Main{
     public static void main(String[] args) {
         Thread thread=new MyThread();
         Thread thread2=new MyThread();
         thread.start(); // 线程开启
         thread2.start(); // 线程开启
     }
 }

• 实现Runnable创建线程类:

　　

 // 实现Runnable创建线程类
 class MyRunnable implements Runnable{
     private Object shareData; // 实现数据共享
     public void run(){
         System.out.println("当前线程是"+Thread.currentThread.getName());
     }
 }
 //创建线程
 class Main{
     public static void main(String[] args) {
         // 两个线程将共享shareData共享数据
         Runnable runa=new MyRunnable();
         Thread thread=new MyThread(runa);
         Thread thread2=new MyThread(runa);
         thread.start(); // 线程开启
         thread2.start(); // 线程开启
     }
 }

• 使用Callable 和 Future接口:

　　

 /**
  * 该代码来源: @蛊惑Into
  * Callable 和 Future接口
  * Callable是类似于Runnable的接口，实现Callable接口的类和实现Runnable的类都是可被其它线程执行的任务。
  * Callable和Runnable有几点不同：
  * （1）Callable规定的方法是call()，而Runnable规定的方法是run().
  * （2）Callable的任务执行后可返回值，而Runnable的任务是不能返回值的。
  * （3）call()方法可抛出异常，而run()方法是不能抛出异常的。
  * （4）运行Callable任务可拿到一个Future对象，
  * Future 表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。
  * 通过Future对象可了解任务执行情况，可取消任务的执行，还可获取任务执行的结果。
  */
 public class CallableAndFuture {

     public static class  MyCallable  implements Callable{
           private int flag = 0;
           public MyCallable(int flag){
                   this.flag = flag;
           }
           public String call() throws Exception{
             if (this.flag == 0){
                       return "flag = 0";
             }
             if (this.flag == 1){
                 try {
                     while (true) {
                             System.out.println("looping.");
                             Thread.sleep(2000);
                     }
                 } catch (InterruptedException e) {
                               System.out.println("Interrupted");
                 }
                 return "false";
             } else {
                        throw new Exception("Bad flag value!");
             }
         }
     }

     public static void main(String[] args) {

        // 定义3个Callable类型的任务
         MyCallable task1 = new MyCallable(0);
         MyCallable task2 = new MyCallable(1);
         MyCallable task3 = new MyCallable(2);      

        // 创建一个执行任务的服务
        ExecutorService es = Executors.newFixedThreadPool(3);
         try {
            // 提交并执行任务，任务启动时返回了一个Future对象，

             // 如果想得到任务执行的结果或者是异常可对这个Future对象进行操作
             Future future1 = es.submit(task1);
            // 获得第一个任务的结果，如果调用get方法，当前线程会等待任务执行完毕后才往下执行
             System.out.println("task1: " + future1.get());

             Future future2 = es.submit(task2);
            // 等待5秒后，再停止第二个任务。因为第二个任务进行的是无限循环
             Thread.sleep(5000);
             System.out.println("task2 cancel: " + future2.cancel(true));

            // 获取第三个任务的输出，因为执行第三个任务会引起异常
             // 所以下面的语句将引起异常的抛出
             Future future3 = es.submit(task3);
             System.out.println("task3: " + future3.get());
         } catch (Exception e){
             System.out.println(e.toString());
         }

        // 停止任务执行服务
         es.shutdownNow();

     }

 }

• 线程控制:

　　

 // 线程控制

 join()线程---必须等线程th执行完成后才能继续向下执行
 ...
 th.start();
 th.join();
 ... 

 yield()礼让---注意和线程通信中wait()区分,yield将线程放到就绪队列,而wait将其放到阻塞队列
 ...th.doSomething...
 th.yield();
 ...th.doSomethingElse...

 sleep()睡眠---线程睡眠,将进入阻塞队列
 ...doSomething...
 Thread.sleep(1000);
 ...continueDoSomething...

 setDaemon()后台线程---将线程设置为后台线程,将在前台线程都死亡后自动死亡
 ....
 th.setDaemon(true);
 ....

 setPrority()优先级---设置优先级
 ...
 th.setPrority(5);
 th.start();
 ...

• 线程同步的3种实现:

　　

 /* 线程同步的3种实现:
 *    1.同步代码块:锁对象可以是任意对象
                     synchronized(obj){同步代码块}
 *    2.同步方法:
             2.1 普通同步方法,锁对象是this
                     public synchronized void fun(){...}
             2.2 静态同步方法,锁对象是.class字节码对象
                     public static synchronized void fun(){...}
     3.同步锁:javaAPI提供了多种锁,如读写锁等,以及一些工具类的锁(同时具有同步和通讯特点)
             private Lock lock=new ReentrantLock();
             ...
             lock.lock();
             ...doSomething...
             lock.unLock();
 *
 *
 *以下着重介绍几种工具类的锁使用:
         Samaphore
         CyclicBarrier
         CountDownLatch
 */
 /**
  * 线程互斥与通信:
  *         线程通讯之传统线程通讯: Semaphore信号灯工具
  *         传统的互斥,是由线程本身来控制锁的占有和释放,这就导致必须当前线程完成,或是主动让出锁,下一个线程才有机会,
  *         而semaphore工具, 提供相当于专门的锁的管理方全权控制索,任何线程的请求都通过管理方的许可,这样就解放了锁的控制权,让多个线程共享锁
  *
  *共有3盏灯,一次来了10个人,只用其中的3个人能够拿到等,当有灯还回的时候,等候队列的人才有机会拿到灯
  *可用于死锁恢复的一些场景
  *
  * @throws Exception
  * @author ware E-mail:
  * @version create time: 20172017年3月1日下午11:35:41
  */
 public class ThreadCommunication3 {

     public static void main(String[] args) {
         final Semaphore sp=new Semaphore(3, true);

         ExecutorService pool = Executors.newCachedThreadPool();

         for (int i = 0; i < 10; i++) {
             Runnable task=new Runnable() {
                 @Override
                 public void run() {
                     try {
                         sp.acquire(); // 请求锁
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                     System.out.println("线程"+Thread.currentThread().getName()+"已经进入---可用数"+(3-sp.availablePermits()));

                     try {
                         Thread.sleep(1000);
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }

                     System.out.println("线程"+Thread.currentThread().getName()+"准备离开");

                     sp.release(); //释放锁
                 }
             };

             pool.submit(task);
         }

     }

 }

 /**
  * 线程互斥与通信:
  *         线程通讯之传统线程通讯: CyclicBarrier工具
  *         所有规定的线程必须都在完成某一项工作之后才能继续下一项工作
  *
  * 如: 班级郊游,只有所有的人都到了集合点(工作1)才能出发(工作2)
  *
  * @throws Exception
  * @author ware E-mail:
  * @version create time: 20172017年3月1日下午11:35:41
  */
 public class ThreadCommunication4 {

     public static void main(String[] args) {
         final CyclicBarrier cb=new CyclicBarrier(4); // 约定有多少个人

         ExecutorService pool = Executors.newCachedThreadPool();

         for (int i = 0; i < 4; i++) {
             Runnable task=new Runnable() {
                 @Override
                 public void run() {

                     try {
                         // 第一阶段工作
                         Thread.sleep((long) (Math.random()*1000));
                         System.out.println(Thread.currentThread().getName()+"到达集合点,当前共有"+cb.getNumberWaiting()+"人在等待");
                         cb.await();

                         // 第二阶段工作
                         Thread.sleep((long) (Math.random()*1000));
                         System.out.println(Thread.currentThread().getName()+"出发中"+cb.getNumberWaiting()+"人出发中");
                         cb.await();

                         // 第三阶段工作
                         Thread.sleep((long) (Math.random()*1000));
                         System.out.println(Thread.currentThread().getName()+"到达景点"+cb.getNumberWaiting()+"人到达景点");
                         cb.await();

                     } catch (Exception e) {
                         e.printStackTrace();
                     }

                 }

             };

             pool.submit(task);
         }

     }

 }

 /**
  * 线程互斥与通信:
  *         线程通讯之传统线程通讯: CountDownLatch工具
  *         如同一个倒计时器,当countDown()到0的时候,所有等该"计时器"的线程都会受到消息
  *
  * 如: 所有的运动员都在等裁判的命令,裁判一声令下,所有的运动员收到消息开始跑,裁判等到所有的人都跑到终点了才宣布结构
  *
  * @throws Exception
  * @author ware E-mail:
  * @version create time: 20172017年3月1日下午11:35:41
  */
 public class ThreadCommunication6 {

     public static void main(String[] args) {
         final CountDownLatch cdOrder=new CountDownLatch(1); // 裁判命令
         final CountDownLatch cdAnswer=new CountDownLatch(4); // 运动员的消息状态

         ExecutorService pool = Executors.newCachedThreadPool();

         // 4个运动员
         for (int i = 0; i < 4; i++) {
             Runnable task=new Runnable() {
                 @Override
                 public void run() {

                     try {
                         System.out.println(Thread.currentThread().getName()+"---已经准备好了,等待命令");

                         cdOrder.await(); // 等命令

                         System.out.println("等到命令并开跑");
                         Thread.sleep((long) (Math.random()*1000));
                         System.out.println(Thread.currentThread().getName()+"跑完全程了");

                         cdAnswer.countDown();

                     } catch (Exception e) {
                         e.printStackTrace();
                     }

                 }

             };

             pool.submit(task);
         }

         // 1个裁判
         Runnable coach=new Runnable() {
             @Override
             public void run() {
                 try {
                     System.out.println(Thread.currentThread().getName()+"准备开炮.....碰...");
                     cdOrder.countDown();
                     System.out.println(Thread.currentThread().getName()+"命令已发出,等待结果...");

                     cdAnswer.await();
                     System.out.println(Thread.currentThread().getName()+"比赛结束,成绩出来了");

                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }

             }
         };
         pool.submit(coach);

     }

 }

• 线程通讯:

　　

 /*
 *3种线程通讯:
     1. 传统线程通讯--wait(),notify();
     2. Condition线程通讯;
     2. BlockingQueue阻塞队列
 *
 */
 /**
  * 线程互斥与通信:
  *         线程通讯之传统线程通讯: wait(),notify(),notifyAll()(必须配合synchronized关键字)
  *
  *父线程执行10次,
  *子线程执行50次
  * @author ware E-mail:
  * @version create time: 20172017年3月1日下午11:35:41
  */
 public class ThreadCommunication {
     private static boolean isSub=false;

     public synchronized void doit(){
         while(true){
             while(isSub){
                 try {
                     this.wait();
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
             try {
                 Thread.sleep(1000);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
             for (int i = 0; i < 10; i++) {
                 System.out.println("main"+"----------"+i);
             }
             isSub=true;
             this.notify();
         }

     }
     public synchronized void doit2(){
         while(true){
             while(!isSub){
                 try {
                     this.wait();
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
             try {
                 Thread.sleep(1000);
             } catch (InterruptedException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }
             for (int i = 0; i < 50; i++) {
                 System.out.println("sub"+"----------"+i);
             }
             isSub=false;
             this.notify();
         }
     }

     public static void main(String[] args) {
         ThreadCommunication tc=new ThreadCommunication();

         // 父线程
         Thread fatherTh=new Thread(){
                 @Override
                 public void run() {
                     tc.doit();
                 }
             };

             // 子线程
         Thread sonTh=new Thread(){
                 @Override
                 public void run() {
                     tc.doit2();
                 }
             };

         fatherTh.start();
         sonTh.start();
     }
 }

 /**
  * 线程互斥与通信:
  *         线程通讯之传统线程通讯: Condition(必须配合Lock使用)

  * 是对阻塞队列的实现: ArrayBlockQueue
  * @throws Exception
  * @author ware E-mail:
  * @version create time: 20172017年3月1日下午11:35:41
  */
 public class ThreadCommunication2 {

     private static final Lock lock=new ReentrantLock();
     private static final Condition notFull=lock.newCondition();
     private static final Condition notEmpty=lock.newCondition();

     private Object resources[];

     int putIndex; // 下一个可取的资源索引
     int takeIndex; // 下一个可以存放资源的索引
     int count; // 当前总资源数

     public ThreadCommunication2(int resourceLimit) {
         resources=new Object[resourceLimit];
         this.putIndex=0;
         this.takeIndex=0;
         this.count=0;
     }

     public void put(Object taskResource){
         lock.lock();
         try {
             while(count==resources.length){
                 notFull.await();
             }
             System.out.println("-----------------put");
             resources[putIndex]=taskResource;
             putIndex=(putIndex%resources.length);
             count++;
             notEmpty.signalAll();
         } catch (Exception e) {
             e.printStackTrace();
         }finally{
             lock.unlock();
         }
     }

     public Object take(){
         Object result=null;
         lock.lock();
         try {
             while(count==0){
                 notEmpty.await();
             }
             System.out.println("----------------take");
             result=resources[takeIndex];
             takeIndex=(takeIndex+1)%resources.length;
             count--;

             notFull.signalAll();
         } catch (Exception e) {
             e.printStackTrace();
         }finally{
             lock.unlock();
         }

         return result;
     }

     public static void main(String[] args) {
         ThreadCommunication2 tc=new ThreadCommunication2(7); // 资源队列的长度为7

         // 开10个放线程
         for (int i = 0; i < 10; i++) {
             new Thread(new Runnable() {
                 @Override
                 public void run() {
                     tc.put(Thread.currentThread().getName());
                 }
             }).start();
         }

         // 开10个拿线程
         for (int i = 0; i < 10; i++) {
             new Thread(new Runnable() {
                 @Override
                 public void run() {
                     System.out.println(tc.take());
                 }
             }).start();
         }
     }

 }

 /**
 *BlockingQueue阻塞队列
 *放线程在队列满的时候直接放弃,通知拿线程,然后进入阻塞队列,
 *拿线程在队列空的时候直接放弃,通知放线程,然后进入阻塞队列,
 */
 public class DequeueTest {  

     private final static BlockingQueue<Object> queue=new ArrayBlockingQueue<>(5);

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

         // 开10个放线程
         for (int i = 0; i < 10; i++) {
             new Thread(new Runnable() {
                 @Override
                 public void run() {
                     queue.add(Thread.currentThread().getName());
                 }
             }).start();
         }

         // 开10个拿线程
         for (int i = 0; i < 10; i++) {
             new Thread(new Runnable() {
                 @Override
                 public void run() {
                     System.out.println(queue.remove());
                 }
             }).start();
         }

     }

 }

• 线程数据共享:

　　

 /* 线程数据共享:
  *        1.多个线程间共享同一个数据:
             1.1.多个线程的执行代码相同---多个线程共用一个Runnable的实例, 那么Runnable中的类成员将被共享;
  *             1.2.多个线程的执行代码不同---为多个Runnable对象传入同一个实体对象
  *             1.3.多个线程的执行代码不同---将多个Runnable设置为内部类,将共享实体设置为外部类成员变量
  *        2.一个线程的多个代码块共享一个数据:
  *            2.1 将 (线程,数据对象) 放到一个map中,
  *            2.2 一般使用java类库提供的ThreadLocal,实现原理同上,但是更优雅,而且会在线程结束后自动清理
  *
  * 线程间的数据共享比较简单,这里着重介绍线程内的数据共享
  */
  /**
  * 线程范围内的共享:多个模块在同一个线程中运行时要共享一份数据
  *
  * 解决方式: 使用ThreadLocal---优雅版---将线程与数据分离
  *
  * @param
  * @return
  * @throws Exception
  * @author ware E-mail:
  * @version create time: 20172017年3月2日上午9:07:16
  */
 public class ThreadScopeShared4 {
 //    private static ThreadLocal<Integer> local=new ThreadLocal<>();

     public static void main(String[] args) {
         for (int i = 0; i < 3; i++) {
             new Thread(new Runnable() {
                 @Override
                 public void run() {
 //                    int data=new Random().nextInt();
 //                    local.set(data);

                     ThreadScopeSharedData.getInstance().setAge(new Random().nextInt());
                     ThreadScopeSharedData.getInstance().setName("vivi");
                     new A().getNum();
                     new B().getNum();
                 }
             }).start();
         }

     }

     static class A{ // 模块A
         public void getNum(){
             int age=ThreadScopeSharedData.getInstance().getAge();
             String name=ThreadScopeSharedData.getInstance().getName();
             System.out.println(Thread.currentThread().getName()+"---------"+age);
         }
     }
     static class B{ // 模块B
         public void getNum(){
             int age=ThreadScopeSharedData.getInstance().getAge();
             String name=ThreadScopeSharedData.getInstance().getName();
             System.out.println(Thread.currentThread().getName()+"---------"+age);
         }
     }
 }

 // 专门与线程绑定的对象
 class ThreadScopeSharedData{
     private ThreadScopeSharedData() {}
     public static ThreadScopeSharedData getInstance(){
         ThreadScopeSharedData instance=map.get();
         if(instance==null){
             instance=new ThreadScopeSharedData();
             map.set(instance);
         }
         return instance;
     }

     private static ThreadLocal<ThreadScopeSharedData> map=new ThreadLocal<>();

     private int age;
     private String name;
     public int getAge() {
         return age;
     }
     public void setAge(int age) {
         this.age = age;
     }
     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }

 }

• 线程池:
  • 详细:http://www.cnblogs.com/murthy/p/6495340.html

Normal
0

7.8 磅
0
2

false
false
false

EN-US
ZH-CN
X-NONE

/* Style Definitions */
table.MsoNormalTable
{mso-style-name:普通表格;
mso-tstyle-rowband-size:0;
mso-tstyle-colband-size:0;
mso-style-noshow:yes;
mso-style-priority:99;
mso-style-parent:"";
mso-padding-alt:0cm 5.4pt 0cm 5.4pt;
mso-para-margin-top:0cm;
mso-para-margin-right:0cm;
mso-para-margin-bottom:10.0pt;
mso-para-margin-left:0cm;
line-height:115%;
mso-pagination:widow-orphan;
font-size:11.0pt;
font-family:"Calibri",sans-serif;
mso-ascii-font-family:Calibri;
mso-ascii-theme-font:minor-latin;
mso-hansi-font-family:Calibri;
mso-hansi-theme-font:minor-latin;
mso-bidi-font-family:"Times New Roman";
mso-bidi-theme-font:minor-bidi;}