Java入门——（4）多线程
关键词：线程、Thread、Runnable、sleep()、yield()、join()、同步
一、线程的概述
在一个操作系统中，每个独立执行的程序都可以称为一个进程，也就是“正在运行的程 序”。而在进程中还可以有多个执行单元同时执行，这些执行单元可以看作程序执行的一条 条线索，被称为线程。Java 运行环境是一个包含了不同的类和程序的单一进程。线程可以被 称为轻量级进程。线程需要较少的资源来创建和驻留在进程中，并且可以共享进程中的资源。
二、线程的创建
1、Java提供了两个多线程实现方式：
①一种继承java.lang 包下的Thread类，复写了Thread类的run( )方法，在run( )方法中实现运行在线程上的代码，提供一个start（）方法用于启动新线程。
创建对象示例如：MyThread myTread = new MyTread();
1 public class Example02 {
2 public static void main(String[] args) {
3 MyThread myThread = new MyThread();//创建线程MyThread的线程对象
4 myThread.start();//开启线程
5 while (true){ //通过死循环语句打印输出
6 System.out.println("main（）方法在运行");
7 }
8 }
9 }
10 class MyThread extends Thread{
11 public void run(){
12 while (true){
13 System.out.println("MyThread 类的run（）方法");
14 }
15 }
16 }
②一种实现java.lang.Runnable接口，同样在run( )方法中实现运行在线程上的代码，提供一个start（）方法用于启动新线程。
创建对象示例如：MyThread myTread = new MyTread();
Thread thread = new Thread(myTread);
1 public class Example03 {
2 public static void main(String[] args) {
3 MyThread myThread = new MyThread();//创建线程MyThread的线程对象
4 Thread thread = new Thread(myThread);//创建线程对象
5 thread.start();//开启线程，执行线程中的run（）方法
6 while (true){ //通过死循环语句打印输出
7 System.out.println("main（）方法在运行");
8 }
9 }
10 }
11 class MyThread implements Runnable{
12 public void run(){ //线程的代码段，当调用start（）方法时，线程从此处开始
13 while (true){
14 System.out.println("MyThread 类的run（）方法");
15 }
16 }
17 }
2、实现Runnable接口相对于继承Thread类来说有如下好处：
①适合多个相同的程序代码的线程去处理同一个资源的情况，把线程同程序代码、数据有效的分离；
②可以避免由于java的单继承带来的局限性（一个类一旦继承了某个父类就无法再继承Thread类）。
3、所谓的后台线程，是指在程序运行的时候在后台提供一种通用服务的线程，并且这种线程并不属于程序中不可或缺的部分。因此当所有的非后台线程结束时，程序也就终止了，同时会杀死所有后台线程。反过来说，只要有任何非后台线程(用户线程)还在运行，程序就不会终止。后台线程在不执行finally子句的情况下就会终止其run方法。后台线程创建的子线程也是后台线程。
在某个线程对象在启动之前（start（）方法之前）调用setDaemon（true）语句，这个线程就变成一个后台线程。
三、线程的生命周期及状态转换
1、新建状态（new）
此时不能运行，仅仅由Java虚拟机为其分配内存。
2、就绪状态（Runnable）
当线程对象调用start（）方法后，该线程就进入就绪状态（也称可运行状态），位于运行池中，此时已具备运行条件，能否获得CPU的使用权开始运行，还需要等待系统的调度。
3、运行状态（Running）
就绪线程获得CPU使用权，开始执行run（）方法中的线程执行体，则该线程处于运行状态。只有处于就绪状态的线程才能转换到运行状态。
4、阻塞状态（Blocked）
由阻塞状态状态转换成就绪状态：
①当线程试图获取某个对象的同步锁时，如果该锁被其他线程所持有，则当前线程会进入阻塞状态，如果想从阻塞状态进入就绪状态必须得获取到其他线程所持有的锁。
②当线程调用了一个阻塞式IO方法时，该线程就会进入阻塞状态，如果想进入就绪状态就必须要等到这个阻塞的IO方法返回。
③当线程调用了某个对象的wait（）方法时，也会使线程进入阻塞状态，如果想进入就绪状态就需要使用notify（）方法唤醒该线程。
④当线程调用了Thread的sleep（long mills）方法时，也会使线程进入阻塞状态，在这种情况下，只需等到线程睡眠的时间到以后，线程就会自动进入就绪状态。
⑤当一个线程中调用了另一个线程的join（）方法时，会使当前线程进入阻塞状态，在这种情况下，需要等到新加入的线程运行结束后才会结束阻塞状态，加入就绪状态。
注意：线程从阻塞状态只能进入就绪状态而不能直接进入运行状态。
5、死亡状态（Terminated）
线程run（）执行完或线程抛出未捕获异常、错误，线程就会进入死亡状态。一旦进入死亡状态，线程将不再拥有运行的资格，也不能转换到其他状态。
四、线程的调度
1、线程的优先级
每一个 Java 线程都有一个优先级，这样有助于操作系统确定线程的调度顺序。
Java 线程的优先级是一个整数，其取值范围是 1 （Thread.MIN_PRIORITY ） - 10 （Thread.MAX_PRIORITY ）。如：thread.setPriority(10);
默认情况下，每一个线程都会分配一个普通优先级 NORM_PRIORITY（5）。
具有较高优先级的线程对程序更重要，并且应该在低优先级的线程之前分配处理器资源。但是，线程优先级不能保证线程执行的顺序，而且非常依赖于平台。
2、线程休眠
Thread.sleep（long millis）方法声明抛出InerruptedException异常，因此在调用此方法时应该捕获异常，或者声明抛出该异常。该方法静态方法，只能控制当前线程休眠。
1 public class Example08 {
2 public static void main(String[] args) throws Exception{
3 // 创建一个线程
4 new Thread(new SleepThread()).start();
5 for (int i= 1;i<=10;i++){
6 if (i==5){
7 Thread.sleep(2000);//当前线程休眠2秒
8 }
9 System.out.println("主线程正在输出："+i);
10 Thread.sleep(500);//当前线程休眠500毫秒
11 }
12 }
13 }
14 class SleepThread implements Runnable{
15 @Override
16 public void run() {
17 for (int i= 1;i<=10;i++){
18 if (i==3){
19 try{
20 Thread.sleep(2000);
21 }catch (InterruptedException e ){
22 e.printStackTrace();
23 }
24 }
25 System.out.println("线程一正在输出："+i);
26 try{
27 Thread.sleep(500);
28 } catch (Exception e ){
29 e.printStackTrace();
30 }
31 }
32
3、线程让步
线程让步可以通过yield（）方法实现，该方法与sleep（）方法相似，都是可以让当前正在运行的线程暂停，区别在于yield（）方法不会阻塞该线程，它只是将该线程转换成就绪状态，让系统的调度器重新调度一次。当某个线程调用yield（）方法之后，只有与当前线程优先级相同或者更高的线程才能获得执行的机会。
1 //定义YieldThread类继承Thread类
2 class YieldThread extends Thread{
3 // 定义一个有参构造方法
4 public YieldThread(String name){
5 super(name);//调用父类的构造方法
6 }
7
8 @Override
9 public void run() {
10 for (int i= 0;i<5;i++){
11 System.out.println(Thread.currentThread().getName()+"___"+i);
12 if (i==3){
13 System.out.print("线程让步");
14 Thread.yield();//线程运行至此，做出让步
15 }
16 }
17 }
18 }
19 public class Example09 {
20 public static void main(String[] args) {
21 //创建两个线程
22 Thread t1= new YieldThread("线程A");
23 Thread t2= new YieldThread("线程B");
24 //开启两个线程
25 t1.start();
26 t2.start();
27 }
28
29 }
4、线程插队
当某个线程中调用其他线程的join（）方法时，调用的线程将被阻塞，直到被join（）方法加入的线程执行完成后它才会继续运行。
1 public class Example10 {
2 public static void main(String[] args) throws Exception{
3 // 创建线程
4 Thread t = new Thread(new EemergencyThread(),"线程一");
5 t.start();
6 for (int i=1;i<6;i++){
7 System.out.println(Thread.currentThread().getName()+"输入："+i);
8 if (i==2){
9 t.join(); //调用join()方法
10 }
11 Thread.sleep(500);
12 }
13 }
14 }
15 class EemergencyThread implements Runnable{
16 @Override
17 public void run() {
18 for (int i =1;i<6;i++){
19 System.out.println(Thread.currentThread().getName()+"输入："+i);
20 try{
21 Thread.sleep(500);
22 }catch (InterruptedException e){
23 e.printStackTrace();
24 }
25 }
26 }
27 }
五、多线程同步
1、同步代码块：lock是一个锁的对象，它是同步代码块的关键，它可以是任意类型的对象，但多个线程共享的锁对象必须是唯一的。“任意”说的是共享锁对象的类型。
synchronized(lock){ 操作共享资源代码块 }
2、同步方法：
synchronized 返回值类型 方法名（[参数1，......]）{ }
示例：
1 //定义Ticket1类实现Runnable接口
2 class Ticket1 implements Runnable{
3 private int tickets=10; //定义变量tickets，并赋值10
4 /* 同步代码块用法
5 Object lock = new Object();//定义任意一个对象，用做同步代码块的锁
6 public void run(){
7 while (true){
8 synchronized(lock){
9 try {
10 Thread.sleep(10);
11 } catch (InterruptedException e) {
12 e.printStackTrace();
13 }
14 if(tickets>0){
15 System.out.println(Thread.currentThread().getName()
16 + "---卖出的票" + tickets--);
17 }else{
18 break;
19 }
20 }
21 }
22
23 }*/
24
25 public void run(){
26 while (true){
27 saleTicket(); //调用售票方法
28 if (tickets<=0){
29 break;
30 }
31 }
32
33 }
34 //定义一个同步方法saleTicket（）
35 private synchronized void saleTicket (){
36 if (tickets>0) {
37 try {
38 Thread.sleep(10);
39 } catch (InterruptedException e) {
40 e.printStackTrace();
41 }
42 System.out.println(Thread.currentThread().getName() +
43 "---卖出的票" + tickets--);
44 }
45 }
46 }
47 public class Example12 {
48 public static void main(String[] args) {
49 Ticket1 ticket =new Ticket1();
50 new Thread(ticket,"线程1").start();
51 new Thread(ticket,"线程2").start();
52 new Thread(ticket,"线程4").start();
53 new Thread(ticket,"线程3").start();
54 }
55 }
4、死锁
死锁是这样一种情形：多个线程同时被阻塞，它们中的一个或者全部都在等待某个资源被释放。由于线程被无限期地阻塞，因此程序不可能正常终止。
java 死锁产生的四个必要条件：
①互斥使用，即当资源被一个线程使用(占有)时，别的线程不能使用
②不可抢占，资源请求者不能强制从资源占有者手中夺取资源，资源只能由资源占有者主动释放。
③请求和保持，即当资源请求者在请求其他的资源的同时保持对原有资源的占有。
④循环等待，即存在一个等待队列：P1占有P2的资源，P2占有P3的资源，P3占有P1的资源。这样就形成了一个等待环路。
六、多线程通信
在Object类中提供了wait（），notify（），notifyAll（）方法用于解决线程的通信问题，即让线程按照一定的顺序轮流执行。
唤醒线程的方法：
| 方法声明 | 功能描述 |
| void wait（） | 使当前线程放弃同步锁并进入等待，直到其他线程进入此同步锁，并调用notify（）方法或notifyAll（）方法唤醒该线程为止 |
| void notify（） | 唤醒此同步锁上等待的第一个调用wait()方法的线程 |
| void notifyAll() | 唤醒此同步锁上调用wait()方法的所有线程 |
wait（），notify（），notifyAll（）这三个方法的调用者都应该是同步锁对象，如果这三个方法的调用者不是同步锁对象，Java虚拟机就会抛出IllegalMonitorStateException 。
示例存取数据：
1 class Storage{
2 private int[] cells =new int[10];// 数组存储数组
3 private int inPos,outPos;// inPos表示存入时数组下标，outPos表示取出时数组下标
4 private int count;//存入或取出数据的数量
5 public synchronized void put(int num){ //定义一个put()方法向数组中存入数据
6 try {
7 //如果放入数据等于cells的长度，此线程等待
8 while (count == cells.length) {
9 this.wait();
10 }
11 cells[inPos] = num;//向数组中放入数据
12 System.out.println("cells[" + inPos + "]中放入数据---" + cells[inPos]);
13 inPos++;//存完元素让位置加1
14 if (inPos == cells.length)
15 inPos = 0;//当inPos为数组长度是10，将其置为0
16 count++;
17 this.notify();
18 }catch (Exception e){
19 e.printStackTrace();
20 }
21 }
22 //定义一个get()方法从数组中取出数据
23 public synchronized void get(){
24 try{
25 while (count==0){
26 this.wait();
27 }
28 int data=cells[outPos];
29 System.out.println("从cells["+outPos+"]中取出数据"+data);
30 cells[outPos]=0;//取出后，当前数据置零
31 outPos++; //取完元素后让位置加1
32 if (outPos==cells.length)
33 outPos=0;
34 count--;//每取出一个元素count减1
35 this.notify();
36 }catch (Exception e){
37 e.printStackTrace();
38 }
39 }
40 }
41 class Input implements Runnable{ //输入线程类
42 private Storage st;
43 private int num; //定义一个变量num
44 Input(Storage st){ //通过构造方法接收一个Storage对象
45 this.st=st;
46 }
47 public void run(){
48 while (true){
49 st.put(num++);//将num存入数组，每次存入后num自增
50 }
51 }
52 }
53 class Output implements Runnable{ //输出线程类
54 private Storage st;
55 Output(Storage st){ //通过构造方法接收一个Storage对象
56 this.st=st;
57 }
58 public void run(){
59 while (true){
60 st.get();//循环取出元素
61 }
62 }
63 }
64 public class Example17 {
65 public static void main(String[] args) {
66 Storage st=new Storage();//创建数组存储类对象
67 Input input=new Input(st);//创建Input对象传入Storage对象
68 Output output=new Output(st);//创建Output对象传入Storage对象
69 new Thread(input).start();//开启新线程
70 new Thread(output).start();//开启新线程
71
72 }
73 }
运行结果
cells[1]中放入数据---214311 cells[2]中放入数据---214312 cells[3]中放入数据---214313 cells[4]中放入数据---214314 cells[5]中放入数据---214315 cells[6]中放入数据---214316 cells[7]中放入数据---214317 cells[8]中放入数据---214318 cells[9]中放入数据---214319 cells[0]中放入数据---214320 从cells[1]中取出数据214311 从cells[2]中取出数据214312 从cells[3]中取出数据214313 从cells[4]中取出数据214314 从cells[5]中取出数据214315 从cells[6]中取出数据214316 从cells[7]中取出数据214317 从cells[8]中取出数据214318 从cells[9]中取出数据214319 从cells[0]中取出数据214320
多线程累加例子：
模拟10个线程，第一个线程从1加到10，第二个线程从11加到20.....第十个线程从91加到100，最后在把10个线程结果相加。
1 public class Accumulator extends Thread {
2 private int stratNum;
3 public static int sum;
4 public Accumulator(int startNum) {
5 this.stratNum = startNum;
6 }
7 public static synchronized void add(int num) {
8 sum += num;
9 }
10 public void run() {
11 int sum = 0;
12 for (int i = 0; i < 10; i++) {
13 sum += stratNum + i;
14 }
15 add(sum);
16 }
17 public static void main(String[] args) throws Exception {
18 Thread[] threadList = new Thread[10];
19 for (int i = 0; i < 10; i++) {
20 threadList[i] = new Accumulator(10 * i + 1);
21 threadList[i].start();
22 }
23 for (int i = 0; i < 10; i++) {
24 threadList[i].join();
25 }
26 System.out.println("Sum is : " + sum);
27 }
28 }
