Java多线程

线程概念

一：程序 进程 线程

1. 程序：Program 编写的代码，指令集，静态概念
2. 进程：Process 操作系统调度程序，动态概念  作为资源分配的单位
3. 线程：Thread 进程内多条执行路径 轻量级进程 调度和执行的单位 线程使用的资源是它所属进程的资源 只能共享资源 除CPU外不会为线程分配内存

线程创建

一：继承Thread + 重写run()方法

Rabbit.java

public class Rabbit extends Thread {public void run() {for(int i=0; i<5; i++) {System.out.println("Rabbit: " + i);}}}

启动：创建子类对象 + 调用子类对象.start()方法

RabbitApp.java

public class RabbitApp {public static void main(String[] args) {Rabbit rabbit = new Rabbit();//Tortoise tortoise = new Tortoise();rabbit.start();//tortoise.start();}}

二：实现Runnable接口 + 重写run()方法

Programmer.java

public class Programmer implements Runnable {@Overridepublic void run() {for(int i=0; i<5; i++) {System.out.println("Programmer: " + i);}}}

启动：创建真实角色

       创建代理角色：Thread + 对真实角色的引用

       代理角色.start()

ProgrammerApp.java

public class ProgrammerApp {public static void main(String[] args) {Programmer programmer = new Programmer();Thread proxy = new Thread(programmer);proxy.start();//for(int i=0; i<5; i++) {//System.out.println("main: " + i);//}}}

推荐：使用接口

1. 避免单继承局限性
2. 便于共享资源

三：创建Callable实现类 + 重写call()方法 可以抛检查时异常 前面的run()方法是不能抛异常的

线程状态

一：线程状态转换图

新生状态：用new关键字和Thread类或其子类建立一个线程对象后，该线程对象就处于新生状态。处于新生状态的线程有自己的内存空间，通过调用start方法进入就绪状态（runnable）

就绪状态：处于就绪状态的线程已经具备了运行条件，但还没有分配到CPU，处于线程就绪队列，等待系统为其分配CPU。等待状态并不是执行状态，当系统选定一个等待执行的Thread对象后，它就会从等待执行状态进入执行状态，系统挑选的动作称之为”CPU调度“。一旦获得CPU，线程就进入运行状态并自动调用自己的run方法。

运行状态：在运行状态的线程执行自己的run方法中，代码直到调用其他方法而终止，或等待某资源而阻塞或完成任务而死亡。如果过在给定的时间片内没有执行结束，就会被系统给换下来回到等待执行状态。

运行状态：处于就绪状态的线程获得CPU时间片后，进入运行状态，真正开始执行run方法。

阻塞状态：处于运行状态的线程在某些情况下，如执行了sleep（睡眠）方法，或等待I/O设备等资源，将让出CPU并暂时停止自己的运行，进入阻塞状态。在阻塞状态的线程不能进入就绪队列。只有当引起阻塞的原因消除时，如睡眠时间已到，或等待的I/O设备空闲下来，线程便转入就绪状态，重新到就绪队列中排队等待，被系统选中后从原来停止的位置开始继续执行。

死亡状态：死亡状态是线程生命周期中的最后一个阶段。线程死亡的原因有两个。一个是正常运行的线程完成了它的全部工作；另一个是线程被强制性的终止，如通过执行stop或destroy方法来终止一个线程【不推荐使用这两个方法。前者会产生异常，后者是强制终止，不会释放锁。】

停止线程

一：自然终止 线程体自然执行完毕

二：外部干涉

1. 线程体中定义线程体使用的标识
2. 线程体使用该标识
3. 提供对外的方法改变该标识
4. 外部根据条件调用该方法即可

StopDemo01.java

public class StopDemo01 {public static void main(String[] args) {Study study = new Study();Thread thread = new Thread(study);thread.start();for(int i=0; i<100; i++) {if(i==50) {study.stop();}System.out.println("main thread->" + i);}}}class Study implements Runnable {private boolean flag = true;public void run() {while(flag) {System.out.println("study thread...");}}public void stop() {this.flag = false;}}

线程阻塞

一：join 合并线程

JoinDemo01.java

public class JoinDemo01 extends Thread {public static void main(String[] args) throws Exception {JoinDemo01 joindemo01 = new JoinDemo01();Thread t = new Thread(joindemo01);t.start();for(int i=0; i<100; i++) {if(i==50) {t.join(); //main阻塞}System.out.println("main thread..." + i);}}public void run() {for(int i=0; i<100; i++) {System.out.println("join thread..." + i);}}}<strong></strong>

二：yield 暂停自己的线程 static

YeildDemo01.java

public class YieldDemo01 extends Thread {public static void main(String[] args) {JoinDemo01 joindemo01 = new JoinDemo01();Thread t = new Thread(joindemo01);t.start();for(int i=0; i<100; i++) {if(i%10==0) {Thread.yield(); //暂停本线程main}System.out.println("main thread..." + i);}}public void run() {for(int i=0; i<100; i++) {System.out.println("yield thread..." + i);}}}

三：sleep 休眠，不释放锁 static

1. 与时间相关：倒计时
2. 模拟网络延时

SleepDemo01.java

public class SleepDemo01 {public static void main(String[] args) throws Exception {int num = 10;while(num>=0) {Thread.sleep(1000);System.out.println(num);num--;}}}

线程基本信息

Thread.currentThread() //当前线程 static

setName() //设置名称

getName() //获取名称

isAlive() //判断状态

优先级：概率大小，不是绝对的先后顺序

setPriority() //设置优先级大小

getPriority() //获取优先级

MyThready.java

public class MyThread implements Runnable {private boolean flag = true;private int num = 0;public void run() {while(flag) {System.out.println(Thread.currentThread().getName() + "->" + num);num++;}}public void stop() {this.flag = !this.flag;}}

InfoDemo01.java

public class InfoDemo01 {public static void main(String[] args) throws Exception {MyThread mythread = new MyThread();Thread proxy = new Thread(mythread);proxy.setName("test");System.out.println(proxy.getName());System.out.println(Thread.currentThread().getName());proxy.start();Thread.sleep(100);mythread.stop();}}

InfoDemo02.java

package com.cho3en1.thread.info;public class InfoDemo02 {public static void main(String[] args) throws Exception {MyThread mythread1 = new MyThread();MyThread mythread2 = new MyThread();Thread t1 = new Thread(mythread1);Thread t2 = new Thread(mythread2);t1.setPriority(Thread.MAX_PRIORITY);t2.setPriority(Thread.MIN_PRIORITY);t1.start();t2.start();Thread.sleep(200);mythread1.stop();mythread2.stop();}<h2>}</h2>

线程同步与锁定

同步：并发 多个线程访问同一份资源 确保资源安全 

synchronized -> 同步

一：同步块

synchronized(引用类型|this|类.class) {

}

二：同步方法

synchronized 

SynDemo01.java

public class SynDemo01 {public static void main(String[] args) {Web12306 w = new Web12306();Thread p1 = new Thread(w, "黄牛1");Thread p2 = new Thread(w, "黄牛2");Thread p3 = new Thread(w, "黄牛3");p1.start();p2.start();p3.start();}}class Web12306 implements Runnable {private boolean flag = true;private int num = 50;@Overridepublic void run() {while(flag) {test1();}}public synchronized void test1() {if(num<=0) {flag = false;return;}try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + "抢到了" + num--);}}

三：死锁

SynDemo02.java

public class SynDemo02 {public static void main(String[] args) {Test t1 = new Test();Test t2 = new Test();t1.flag = true;t2.flag = false;Thread proxy1 = new Thread(t1);Thread proxy2 = new Thread(t2);proxy1.start();proxy2.start();}}class Test implements Runnable {public boolean flag; static Object goods = new Object();static Object money = new Object();public void run() {while(true) {test();}}public void test() {if(flag == true) {synchronized (goods) {try {Thread.sleep(500);} catch (InterruptedException e) {e.printStackTrace();}synchronized (money) {System.out.println("一手给钱");}}}if(flag == false) {synchronized (money) {try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}synchronized (goods) {System.out.println("一手给货");}}}}}