Java—多线程编程
一个多线程程序包含两个或多个能并发运行的部分。程序的每一部分都称做一个线程，而且每一个线程定义了一个独立的执行路径。javascript
进程：一个进程包括由操做系统分配的内存空间，包含一个或多个线程。一个线程不能独立的存在，它必须是进程的一部分。一个进程一直运行，直到全部的非守候线程都结束运行后才能结束。html
多线程能知足程序员编写高效率的程序来达到充分利用CPU的目的。java
一 生命周期程序员
- 新建状态:
使用 new 关键字和 Thread 类或其子类创建一个线程对象后，该线程对象就处于新建状态。它保持这个状态直到程序 start() 这个线程。编程
- 就绪状态:
当线程对象调用了start()方法以后，该线程就进入就绪状态。就绪状态的线程处于就绪队列中，要等待JVM里线程调度器的调度。安全
- 运行状态:
若是就绪状态的线程获取 CPU 资源，就能够执行 run()，此时线程便处于运行状态。处于运行状态的线程最为复杂，它能够变为阻塞状态、就绪状态和死亡状态。多线程
- 阻塞状态:
若是一个线程执行了sleep（睡眠）、suspend（挂起）等方法，失去所占用资源以后，该线程就从运行状态进入阻塞状态。在睡眠时间已到或得到设备资源后能够从新进入就绪状态。并发
- 死亡状态:
一个运行状态的线程完成任务或者其余终止条件发生时，该线程就切换到终止状态。ide
二 线程的建立与启动post
Java中线程的建立常见有如三种基本形式
1.继承Thread类，重写该类的run()方法。
建立一个新的类，该类继承Thread类，而后建立一个该类的实例。
继承类必须重写run()方法，该方法是新线程的入口点。它也必须调用start()方法才能执行。
1 class MyThread extends Thread { 2 3 private int i = 0; 4 5 @Override 6 public void run() { 7 for (i = 0; i < 100; i++) { 8 System.out.println(Thread.currentThread().getName() + " " + i); 9 } 10 } 11 }
1 public class ThreadTest { 2 3 public static void main(String[] args) { 4 for (int i = 0; i < 100; i++) { 5 System.out.println(Thread.currentThread().getName() + " " + i); 6 if (i == 30) { 7 Thread myThread1 = new MyThread(); // 建立一个新的线程 myThread1 此线程进入新建状态 8 Thread myThread2 = new MyThread(); // 建立一个新的线程 myThread2 此线程进入新建状态 9 myThread1.start(); // 调用start()方法使得线程进入就绪状态 10 myThread2.start(); // 调用start()方法使得线程进入就绪状态 11 } 12 } 13 } 14 }
输出结果：（多线程执行）存在交叉性。
如上所示，继承Thread类，经过重写run()方法定义了一个新的线程类MyThread，其中run()方法的方法体表明了线程须要完成的任务，称之为线程执行体。当建立此线程类对象时一个新的线程得以建立，并进入到线程新建状态。经过调用线程对象引用的start()方法，使得该线程进入到就绪状态，此时此线程并不必定会立刻得以执行，这取决于CPU调度时机。
2.实现Runnable接口，并重写该接口的run()方法，该run()方法一样是线程执行体，建立Runnable实现类的实例，并以此实例做为Thread类的target来建立Thread对象，该Thread对象才是真正的线程对象。
建立一个线程，最简单的方法是建立一个实现Runnable接口的类。为了实现Runnable，一个类只须要执行一个方法调用run()，
1 class MyRunnable implements Runnable { 2 private int i = 0; 3 4 @Override 5 public void run() { 6 for (i = 0; i < 100; i++) { 7 System.out.println(Thread.currentThread().getName() + " " + i); 8 } 9 } 10 }
1 public class ThreadTest { 2 3 public static void main(String[] args) { 4 for (int i = 0; i < 100; i++) { 5 System.out.println(Thread.currentThread().getName() + " " + i); 6 if (i == 30) { 7 Runnable myRunnable = new MyRunnable(); // 建立一个Runnable实现类的对象 8 Thread thread1 = new Thread(myRunnable); // 将myRunnable做为Thread target建立新的线程 9 Thread thread2 = new Thread(myRunnable); 10 thread1.start(); // 调用start()方法使得线程进入就绪状态 11 thread2.start(); 12 } 13 } 14 } 15 }
相信以上两种建立新线程的方式你们都很熟悉了，那么Thread和Runnable之间究竟是什么关系呢？咱们首先来看一下下面这个例子。
1 public class ThreadTest { 2 3 public static void main(String[] args) { 4 for (int i = 0; i < 100; i++) { 5 System.out.println(Thread.currentThread().getName() + " " + i); 6 if (i == 30) { 7 Runnable myRunnable = new MyRunnable(); 8 Thread thread = new MyThread(myRunnable); 9 thread.start(); 10 } 11 } 12 } 13 } 14 15 class MyRunnable implements Runnable { 16 private int i = 0; 17 18 @Override 19 public void run() { 20 System.out.println("in MyRunnable run"); 21 for (i = 0; i < 100; i++) { 22 System.out.println(Thread.currentThread().getName() + " " + i); 23 } 24 } 25 } 26 27 class MyThread extends Thread { 28 29 private int i = 0; 30 31 public MyThread(Runnable runnable){ 32 super(runnable); 33 } 34 35 @Override 36 public void run() { 37 System.out.println("in MyThread run"); 38 for (i = 0; i < 100; i++) { 39 System.out.println(Thread.currentThread().getName() + " " + i); 40 } 41 } 42 }
一样的，与实现Runnable接口建立线程方式类似，不一样的地方在于
1 Thread thread = new MyThread(myRunnable);
那么这种方式能够顺利建立出一个新的线程么？答案是确定的。至于此时的线程执行体究竟是MyRunnable接口中的run()方法仍是MyThread类中的run()方法呢？经过输出咱们知道线程执行体是MyThread类中的run()方法。其实缘由很简单，由于Thread类自己也是实现了Runnable接口，而run()方法最早是在Runnable接口中定义的方法。
1 public interface Runnable { 2 3 public abstract void run(); 4 5 }
咱们看一下Thread类中对Runnable接口中run()方法的实现：
@Override public void run() { if (target != null) { target.run(); } }
也就是说，当执行到Thread类中的run()方法时，会首先判断target是否存在，存在则执行target中的run()方法，也就是实现了Runnable接口并重写了run()方法的类中的run()方法。可是上述给到的列子中，因为多态的存在，根本就没有执行到Thread类中的run()方法，而是直接先执行了运行时类型即MyThread类中的run()方法。
3.使用Callable和Future接口建立线程。具体是建立Callable接口的实现类，并实现clall()方法。并使用FutureTask类来包装Callable实现类的对象，且以此FutureTask对象做为Thread对象的target来建立线程。
看着好像有点复杂，直接来看一个例子就清晰了。
1 public class ThreadTest { 2 3 public static void main(String[] args) { 4 5 Callable<Integer> myCallable = new MyCallable(); // 建立MyCallable对象 6 FutureTask<Integer> ft = new FutureTask<Integer>(myCallable); //使用FutureTask来包装MyCallable对象 7 8 for (int i = 0; i < 100; i++) { 9 System.out.println(Thread.currentThread().getName() + " " + i); 10 if (i == 30) { 11 Thread thread = new Thread(ft); //FutureTask对象做为Thread对象的target建立新的线程 12 thread.start(); //线程进入到就绪状态 13 } 14 } 15 16 System.out.println("主线程for循环执行完毕.."); 17 18 try { 19 int sum = ft.get(); //取得新建立的新线程中的call()方法返回的结果 20 System.out.println("sum = " + sum); 21 } catch (InterruptedException e) { 22 e.printStackTrace(); 23 } catch (ExecutionException e) { 24 e.printStackTrace(); 25 } 26 27 } 28 } 29 30 31 class MyCallable implements Callable<Integer> { 32 private int i = 0; 33 34 // 与run()方法不一样的是，call()方法具备返回值 35 @Override 36 public Integer call() { 37 int sum = 0; 38 for (; i < 100; i++) { 39 System.out.println(Thread.currentThread().getName() + " " + i); 40 sum += i; 41 } 42 return sum; 43 } 44 45 }
首先，咱们发现，在实现Callable接口中，此时再也不是run()方法了，而是call()方法，此call()方法做为线程执行体，同时还具备返回值！在建立新的线程时，是经过FutureTask来包装MyCallable对象，同时做为了Thread对象的target。那么看下FutureTask类的定义：
1 public class FutureTask<V> implements RunnableFuture<V> { 2 3 //.... 4 5 }
1 public interface RunnableFuture<V> extends Runnable, Future<V> { 2 3 void run(); 4 5 }
因而，咱们发现FutureTask类其实是同时实现了Runnable和Future接口，由此才使得其具备Future和Runnable双重特性。经过Runnable特性，能够做为Thread对象的target，而Future特性，使得其能够取得新建立线程中的call()方法的返回值。
执行下此程序，咱们发现sum = 4950永远都是最后输出的。而“主线程for循环执行完毕..”则极可能是在子线程循环中间输出。由CPU的线程调度机制，咱们知道，“主线程for循环执行完毕..”的输出时机是没有任何问题的，那么为何sum =4950会永远最后输出呢？
缘由在于经过ft.get()方法获取子线程call()方法的返回值时，当子线程此方法还未执行完毕，ft.get()方法会一直阻塞，直到call()方法执行完毕才能取到返回值。
上述主要讲解了三种常见的线程建立方式，对于线程的启动而言，都是调用线程对象的start()方法，须要特别注意的是：不能对同一线程对象两次调用start()方法。
三. Java多线程的就绪、运行和死亡状态
就绪状态转换为运行状态：当此线程获得处理器资源；
运行状态转换为就绪状态：当此线程主动调用yield()方法或在运行过程当中失去处理器资源。
运行状态转换为死亡状态：当此线程线程执行体执行完毕或发生了异常。
此处须要特别注意的是：当调用线程的yield()方法时，线程从运行状态转换为就绪状态，但接下来CPU调度就绪状态中的哪一个线程具备必定的随机性，所以，可能会出现A线程调用了yield()方法后，接下来CPU仍然调度了A线程的状况。
因为实际的业务须要，经常会遇到须要在特定时机终止某一线程的运行，使其进入到死亡状态。目前最通用的作法是设置一boolean型的变量，当条件知足时，使线程执行体快速执行完毕。如：
1 public class ThreadTest { 2 3 public static void main(String[] args) { 4 5 MyRunnable myRunnable = new MyRunnable(); 6 Thread thread = new Thread(myRunnable); 7 8 for (int i = 0; i < 100; i++) { 9 System.out.println(Thread.currentThread().getName() + " " + i); 10 if (i == 30) { 11 thread.start(); 12 } 13 if(i == 40){ 14 myRunnable.stopThread(); 15 } 16 } 17 } 18 } 19 20 class MyRunnable implements Runnable { 21 22 private boolean stop; 23 24 @Override 25 public void run() { 26 for (int i = 0; i < 100 && !stop; i++) { 27 System.out.println(Thread.currentThread().getName() + " " + i); 28 } 29 } 30 31 public void stopThread() { 32 this.stop = true; 33 } 34 35 }
四.Java多线程的阻塞状态与线程控制
上文已经提到Java阻塞的几种具体类型。下面分别看下引发Java线程阻塞的主要方法。
1.join()
join —— 让一个线程等待另外一个线程完成才继续执行。如A线程线程执行体中调用B线程的join()方法，则A线程被阻塞，知道B线程执行完为止，A才能得以继续执行。
1 public class ThreadTest { 2 3 public static void main(String[] args) { 4 5 MyRunnable myRunnable = new MyRunnable(); 6 Thread thread = new Thread(myRunnable); 7 8 for (int i = 0; i < 100; i++) { 9 System.out.println(Thread.currentThread().getName() + " " + i); 10 if (i == 30) { 11 thread.start(); 12 try { 13 thread.join(); // main线程须要等待thread线程执行完后才能继续执行 14 } catch (InterruptedException e) { 15 e.printStackTrace(); 16 } 17 } 18 } 19 } 20 } 21 22 class MyRunnable implements Runnable { 23 24 @Override 25 public void run() { 26 for (int i = 0; i < 100; i++) { 27 System.out.println(Thread.currentThread().getName() + " " + i); 28 } 29 } 30 }
2.sleep()
sleep —— 让当前的正在执行的线程暂停指定的时间，并进入阻塞状态。在其睡眠的时间段内，该线程因为不是处于就绪状态，所以不会获得执行的机会。即便此时系统中没有任何其余可执行的线程，出于sleep()中的线程也不会执行。所以sleep()方法经常使用来暂停线程执行。
前面有讲到，当调用了新建的线程的start()方法后，线程进入到就绪状态，可能会在接下来的某个时间获取CPU时间片得以执行，若是但愿这个新线程必然性的当即执行，直接调用原来线程的sleep(1)便可。
1 public class ThreadTest { 2 3 public static void main(String[] args) { 4 5 MyRunnable myRunnable = new MyRunnable(); 6 Thread thread = new Thread(myRunnable); 7 8 for (int i = 0; i < 100; i++) { 9 System.out.println(Thread.currentThread().getName() + " " + i); 10 if (i == 30) { 11 thread.start(); 12 try { 13 Thread.sleep(1); // 使得thread必然可以立刻得以执行 14 } catch (InterruptedException e) { 15 e.printStackTrace(); 16 } 17 } 18 } 19 } 20 } 21 22 class MyRunnable implements Runnable { 23 24 @Override 25 public void run() { 26 for (int i = 0; i < 100; i++) { 27 System.out.println(Thread.currentThread().getName() + " " + i); 28 } 29 } 30 }
注：睡一个毫秒级够了，由于CPU不会空闲，会切换到新建的线程。
3.后台线程（Daemon Thread）
概念/目的：后台线程主要是为其余线程（相对能够称之为前台线程）提供服务，或“守护线程”。如JVM中的垃圾回收线程。
生命周期：后台线程的生命周期与前台线程生命周期有必定关联。主要体如今：当全部的前台线程都进入死亡状态时，后台线程会自动死亡(其实这个也很好理解，由于后台线程存在的目的在于为前台线程服务的，既然全部的前台线程都死亡了，那它本身还留着有什么用...伟大啊 ! !)。
设置后台线程：调用Thread对象的setDaemon(true)方法能够将指定的线程设置为后台线程。
1 public class ThreadTest { 2 3 public static void main(String[] args) { 4 Thread myThread = new MyThread(); 5 for (int i = 0; i < 100; i++) { 6 System.out.println("main thread i = " + i); 7 if (i == 20) { 8 myThread.setDaemon(true); 9 myThread.start(); 10 } 11 } 12 } 13 14 } 15 16 class MyThread extends Thread { 17 18 public void run() { 19 for (int i = 0; i < 100; i++) { 20 System.out.println("i = " + i); 21 try { 22 Thread.sleep(1); 23 } catch (InterruptedException e) { 24 // TODO Auto-generated catch block 25 e.printStackTrace(); 26 } 27 } 28 } 29 }
判断线程是不是后台线程：调用thread对象的isDeamon()方法。
注：main线程默认是前台线程，前台线程建立中建立的子线程默认是前台线程，后台线程中建立的线程默认是后台线程。调用setDeamon(true)方法将前台线程设置为后台线程时，须要在start()方法调用以前。前天线程都死亡后，JVM通知后台线程死亡，但从接收指令到做出响应，须要必定的时间。
4.改变线程的优先级/setPriority()：
每一个线程在执行时都具备必定的优先级，优先级高的线程具备较多的执行机会。每一个线程默认的优先级都与建立它的线程的优先级相同。main线程默认具备普通优先级。
设置线程优先级：setPriority(int priorityLevel)。参数priorityLevel范围在1-10之间，经常使用的有以下三个静态常量值：
MAX_PRIORITY:10
MIN_PRIORITY:1
NORM_PRIORITY:5
获取线程优先级：getPriority()。
注：具备较高线程优先级的线程对象仅表示此线程具备较多的执行机会，而非优先执行。
1 public class ThreadTest { 2 3 public static void main(String[] args) { 4 Thread myThread = new MyThread(); 5 for (int i = 0; i < 100; i++) { 6 System.out.println("main thread i = " + i); 7 if (i == 20) { 8 myThread.setPriority(Thread.MAX_PRIORITY); 9 myThread.start(); 10 } 11 } 12 } 13 14 } 15 16 class MyThread extends Thread { 17 18 public void run() { 19 for (int i = 0; i < 100; i++) { 20 System.out.println("i = " + i); 21 } 22 } 23 }
本文主要接着前面多线程的两篇文章总结Java多线程中的线程安全问题。
一.一个典型的Java线程安全例子
1 public class ThreadTest { 2 3 public static void main(String[] args) { 4 Account account = new Account("123456", 1000); 5 DrawMoneyRunnable drawMoneyRunnable = new DrawMoneyRunnable(account, 700); 6 Thread myThread1 = new Thread(drawMoneyRunnable); 7 Thread myThread2 = new Thread(drawMoneyRunnable); 8 myThread1.start(); 9 myThread2.start(); 10 } 11 12 } 13 14 class DrawMoneyRunnable implements Runnable { 15 16 private Account account; 17 private double drawAmount; 18 19 public DrawMoneyRunnable(Account account, double drawAmount) { 20 super(); 21 this.account = account; 22 this.drawAmount = drawAmount; 23 } 24 25 public void run() { 26 if (account.getBalance() >= drawAmount) { //1 27 System.out.println("取钱成功， 取出钱数为：" + drawAmount); 28 double balance = account.getBalance() - drawAmount; 29 account.setBalance(balance); 30 System.out.println("余额为：" + balance); 31 } 32 } 33 } 34 35 class Account { 36 37 private String accountNo; 38 private double balance; 39 40 public Account() { 41 42 } 43 44 public Account(String accountNo, double balance) { 45 this.accountNo = accountNo; 46 this.balance = balance; 47 } 48 49 public String getAccountNo() { 50 return accountNo; 51 } 52 53 public void setAccountNo(String accountNo) { 54 this.accountNo = accountNo; 55 } 56 57 public double getBalance() { 58 return balance; 59 } 60 61 public void setBalance(double balance) { 62 this.balance = balance; 63 } 64 65 }
上面例子很容易理解，有一张银行卡，里面有1000的余额，程序模拟你和你老婆同时在取款机进行取钱操做的场景。屡次运行此程序，可能具备多个不一样组合的输出结果。其中一种可能的输出为：
1 取钱成功， 取出钱数为：700.0 2 余额为：300.0 3 取钱成功， 取出钱数为：700.0 4 余额为：-400.0
也就是说，对于一张只有1000余额的银行卡，大家一共能够取出1400，这显然是有问题的。
通过分析，问题在于Java多线程环境下的执行的不肯定性。CPU可能随机的在多个处于就绪状态中的线程中进行切换，所以，颇有可能出现以下状况：当thread1执行到//1处代码时，判断条件为true，此时CPU切换到thread2，执行//1处代码，发现依然为真，而后执行完thread2，接着切换到thread1，接着执行完毕。此时，就会出现上述结果。
所以，讲到线程安全问题，实际上是指多线程环境下对共享资源的访问可能会引发此共享资源的不一致性。所以，为避免线程安全问题，应该避免多线程环境下对此共享资源的并发访问。
二.同步方法
对共享资源进行访问的方法定义中加上synchronized关键字修饰，使得此方法称为同步方法。能够简单理解成对此方法进行了加锁，其锁对象为当前方法所在的对象自身。多线程环境下，当执行此方法时，首先都要得到此同步锁（且同时最多只有一个线程可以得到），只有当线程执行完此同步方法后，才会释放锁对象，其余的线程才有可能获取此同步锁，以此类推...
在上例中，共享资源为account对象，当使用同步方法时，能够解决线程安全问题。只需在run()方法前加上synshronized关键字便可。
1 public synchronized void run() { 2 3 // .... 4 5 }
三.同步代码块
正如上面所分析的那样，解决线程安全问题其实只需限制对共享资源访问的不肯定性便可。使用同步方法时，使得整个方法体都成为了同步执行状态，会使得可能出现同步范围过大的状况，因而，针对须要同步的代码能够直接另外一种同步方式——同步代码块来解决。
同步代码块的格式为：
1 synchronized (obj) { 2 3 //... 4 5 }
其中，obj为锁对象，所以，选择哪个对象做为锁是相当重要的。通常状况下，都是选择此共享资源对象做为锁对象。
如上例中，最好选用account对象做为锁对象。（固然，选用this也是能够的，那是由于建立线程使用了runnable方式，若是是直接继承Thread方式建立的线程，使用this对象做为同步锁会其实没有起到任何做用，由于是不一样的对象了。所以，选择同步锁时须要格外当心...）
四.Lock对象同步锁
上面咱们能够看出，正由于对同步锁对象的选择须要如此当心，有没有什么简单点的解决方案呢？以方便同步锁对象与共享资源解耦，同时又能很好的解决线程安全问题。
使用Lock对象同步锁能够方便的解决此问题，惟一须要注意的一点是Lock对象须要与资源对象一样具备一对一的关系。Lock对象同步锁通常格式为：
1 class X { 2 3 // 显示定义Lock同步锁对象，此对象与共享资源具备一对一关系 4 private final Lock lock = new ReentrantLock(); 5 6 public void m(){ 7 // 加锁 8 lock.lock(); 9 10 //... 须要进行线程安全同步的代码 11 12 // 释放Lock锁 13 lock.unlock(); 14 } 15 16 }
五.wait()/notify()/notifyAll()线程通讯
在博文《Java总结篇系列：java.lang.Object》中有说起到这三个方法，虽然这三个方法主要都是用于多线程中，但实际上都是Object类中的本地方法。所以，理论上，任何Object对象均可以做为这三个方法的主调，在实际的多线程编程中，只有同步锁对象调这三个方法，才能完成对多线程间的线程通讯。
wait()：致使当前线程等待并使其进入到等待阻塞状态。直到其余线程调用该同步锁对象的notify()或notifyAll()方法来唤醒此线程。
notify()：唤醒在此同步锁对象上等待的单个线程，若是有多个线程都在此同步锁对象上等待，则会任意选择其中某个线程进行唤醒操做，只有当前线程放弃对同步锁对象的锁定，才可能执行被唤醒的线程。
notifyAll()：唤醒在此同步锁对象上等待的全部线程，只有当前线程放弃对同步锁对象的锁定，才可能执行被唤醒的线程。
1 package com.qqyumidi; 2 3 public class ThreadTest { 4 5 public static void main(String[] args) { 6 Account account = new Account("123456", 0); 7 8 Thread drawMoneyThread = new DrawMoneyThread("取钱线程", account, 700); 9 Thread depositeMoneyThread = new DepositeMoneyThread("存钱线程", account, 700); 10 11 drawMoneyThread.start(); 12 depositeMoneyThread.start(); 13 } 14 15 } 16 17 class DrawMoneyThread extends Thread { 18 19 private Account account; 20 private double amount; 21 22 public DrawMoneyThread(String threadName, Account account, double amount) { 23 super(threadName); 24 this.account = account; 25 this.amount = amount; 26 } 27 28 public void run() { 29 for (int i = 0; i < 100; i++) { 30 account.draw(amount, i); 31 } 32 } 33 } 34 35 class DepositeMoneyThread extends Thread { 36 37 private Account account; 38 private double amount; 39 40 public DepositeMoneyThread(String threadName, Account account, double amount) { 41 super(threadName); 42 this.account = account; 43 this.amount = amount; 44 } 45 46 public void run() { 47 for (int i = 0; i < 100; i++) { 48 account.deposite(amount, i); 49 } 50 } 51 } 52 53 class Account { 54 55 private String accountNo; 56 private double balance; 57 // 标识帐户中是否已有存款 58 private boolean flag = false; 59 60 public Account() { 61 62 } 63 64 public Account(String accountNo, double balance) { 65 this.accountNo = accountNo; 66 this.balance = balance; 67 } 68 69 public String getAccountNo() { 70 return accountNo; 71 } 72 73 public void setAccountNo(String accountNo) { 74 this.accountNo = accountNo; 75 } 76 77 public double getBalance() { 78 return balance; 79 } 80 81 public void setBalance(double balance) { 82 this.balance = balance; 83 } 84 85 /** 86 * 存钱 87 * 88 * @param depositeAmount 89 */ 90 public synchronized void deposite(double depositeAmount, int i) { 91 92 if (flag) { 93 // 帐户中已有人存钱进去，此时当前线程须要等待阻塞 94 try { 95 System.out.println(Thread.currentThread().getName() + " 开始要执行wait操做" + " -- i=" + i); 96 wait(); 97 // 1 98 System.out.println(Thread.currentThread().getName() + " 执行了wait操做" + " -- i=" + i); 99 }