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;}

巴特西

java多线程一览

最新文章

热门文章