Java 多线程的详解

要想了解多线程，必须先了解线程，而要想了解线程，必须先了解进程，因为线程是依赖于进程而存在的。

什么是进程？
通过任务管理器我们就看到了进程的存在。
而通过观察，我们发现只有运行的程序才会出现进程。
进程：就是正在运行的程序
进程是系统进行资源分配和调用的独立单位，每一个进程都有它自己的内存空间和系统资源。

多进程有什么意义？
单进程的计算机只能做一件事情，而我们现在的计算机可以做多件事情
也就是说现在的计算机都是支持多进程的，可以在同一时间内执行多个任务

看这个问题：
一边玩游戏，一边听音乐是同时进行的吗？
不是，因为单cpu在某一个时间点是只能做一件事情
而我们在玩游戏或者听音乐的时候，是cpu在做着程序间的高效切换，

什么是线程？
在一个进程内又可以执行多个任务。每一个任务就可以看做是一个线程。
线程是程序的执行单元。
单线程：如果程序只有一条执行路径
多线程：如果程序有多条执行路径

多线程有什么意义？
多线程的存在，不是提高程序的执行速度，其实是为了提高应用程序的使用率
程序的执行其实就是再抢CPU的资源，CPU的执行权
多个进程是在抢这个资源，而其中的某一个进程如果执行路径比较多，就会有更高的几率抢到CPU的执行权
我们是不能保证每一个进程或者每一个线程在每个时刻抢到，所以线程的执行有随机性。

Java程序运行原理
java命令会启动java虚拟机，启动JVM，等于启动了一个应用程序，也就是启动了一个进程。该进程会自动启动一个“主线程”，然后主线程去调用某个类的main方法。所以main方法运行在主线程中。

假象：

电脑上的程序同时在运行。“多任务”操作系统能同时运行多个进程（程序）——但实际是由于CPU分时机制的作用，使每个进程都能循环获得自己的CPU时间片。但由于轮换速度非常快，使得所有程序好象是在“同时”运行一样。

多线程的好处：

1. 解决了一个进程里面可以同时运行多个任务（执行路径）。

2. 提供资源的利用率，而不是提供效率。

多线程的弊端:

1. 降低了一个进程里面的线程的执行频率。

2. 对线程进行管理要求额外的 CPU开销。线程的使用会给系统带来上下文切换的额外负担。

3. 公有变量的同时读或写。当多个线程需要对公有变量进行写操作时,后一个线程往往会修改掉前一个线程存放的数据，发生线程安全问题。

线程的死锁。即较长时间的等待或资源竞争以及死锁等多线程症状。

一，创建线程的方式一：

继承Thread类



getName()是获取线程的名字。

执行后的效果：



问题： 先按照顺序运行完了张三，然后接着再按照顺序运行完李四，我们想要的效果是张三和李四做资源的争夺战，也就是先是张三然后李四，没有顺序的执行。这就证明多线程没有起到效果。

需要重写run方法，把要执行的任务放在run方法中



运行效果如图：



问题： 先按照顺序运行完了张三，然后接着再按照顺序运行完李四，我们想要的效果是张三和李四做资源的争夺战，也就是先是张三然后李四，没有顺序的执行。这就证明多线程没有起到效果。

调用start()方法启动线程



效果图如下：



这时候达到了我们预期的效果。

二，线程的使用细节：

1. 线程的启动使用父类的start()方法

2. 如果线程对象直接调用run()，那么JVN不会当作线程来运行，会认为是普通的方法调用。

3. 线程的启动只能由一次，否则抛出异常

4. 可以直接创建Thread类的对象并启动该线程，但是如果没有重写run()，什么也不执行。

5. 匿名内部类的线程实现方式

三，线程的状态

创建：新创建了一个线程对象。

可运行：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取cpu的执行权。

运行：就绪状态的线程获取了CPU执行权，执行程序代码。

阻临时塞: 阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。

死亡：线程执行完它的任务时。

常见线程的方法：

Thread(String name)     初始化线程的名字
getName()             返回线程的名字
setName(String name)    设置线程对象名
sleep()                 线程睡眠指定的毫秒数。
getPriority()             返回当前线程对象的优先级   默认线程的优先级是5
setPriority(int newPriority) 设置线程的优先级    虽然设置了线程的优先级，但是具体的实现取决于底层的操作系统的实现（最大的优先级是10 ，最小的1 ， 默认是5）。
currentThread()      返回CPU正在执行的线程的对象

class ThreadDemo1 extends Thread
{
public ThreadDemo1(){

}
public ThreadDemo1( String name ){
super( name );
}

public void run(){
int i = 0;
while(i < 30){
i++;
System.out.println( this.getName() + " "+ " : i = " + i);
System.out.println( Thread.currentThread().getName() + " "+ " : i = " + i);
System.out.println( Thread.currentThread() == this );
System.out.println( "getId()" + " "+ " : id = " + super.getId() );
System.out.println( "getPriority()" + " "+ " : Priority = " + super.getPriority() );
}
}
}
class Demo3
{
public static void main(String[] args)
{
ThreadDemo1 th1 = new ThreadDemo1("线程1");
ThreadDemo1 th2 = new ThreadDemo1("线程2");
// 设置线程名
th1.setName( "th1" );
th2.setName( "th2" );
// 设置线程优先级  1 ~ 10
th1.setPriority( 10 );
th2.setPriority( 7 );
// 查看SUN定义的线程优先级范围
System.out.println("max : " + Thread.MAX_PRIORITY );
System.out.println("min : " + Thread.MIN_PRIORITY );
System.out.println("nor : " + Thread.NORM_PRIORITY );
th1.start();
th2.start();
System.out.println("Hello World!");
}
}

写一个模拟买票的例子：



存在问题：这时候启动了四个线程，那么tickets是一个成员变量，也就是在一个线程对象中都维护了属于自己的tickets属性，那么就总共存在了四份。

解决方案一：tickets使用staitc修饰，使每个线程对象都是共享一份属性。



解决方案2：编写一个类实现Runnable接口。

四，创建线程的方式二

创建线程的第二种方式.使用Runnable接口.

该类中的代码就是对线程要执行的任务的定义.

1：定义了实现Runnable接口

2：重写Runnable接口中的run方法，就是将线程运行的代码放入在run方法中

3：通过Thread类建立线程对象

4：将Runnable接口的子类对象作为实际参数，传递给Thread类构造方法

5：调用Thread类的start方法开启线程，并调用Runable接口子类run方法

为什么要将Runnable接口的子类对象传递给Thread的构造函数，因为自定义的run方法所属对象是Runnable接口的子类对象，所以要让线程去执行指定对象的run方法

package cn.itcast.gz.runnable;
public class Demo1 {
public static void main(String[] args) {
MyRun my = new MyRun();
Thread t1 = new Thread(my);
t1.start();
for (int i = 0; i < 200; i++) {
System.out.println("main:" + i);
}
}
}
class MyRun implements Runnable {
public void run() {
for (int i = 0; i < 200; i++) {
System.err.println("MyRun:" + i);
}
}
}

理解Runnable:

Thread类可以理解为一个工人,而Runnable的实现类的对象就是这个工人的工作(通过构造方法传递).Runnable接口中只有一个方法run方法,该方法中定义的事会被新线程执行的代码.当我们把Runnable的子类对象传递给Thread的构造时,实际上就是让给Thread取得run方法,就是给了Thread一项任务.

买票例子使用Runnable接口实现

在上面的代码中故意照成线程执行完后，执行Thread.sleep（100），以让cpu让给别的线程，该方法会出现非运行时异常需要处理，这里必须进行try{}catch（）{}，因为子类不能比父类抛出更多的异常，接口定义中没有异常，实现类也不能抛出异常。

运行发现票号出现了负数，显示了同一张票被卖了4次的情况。

出现了同样的问题。如何解决？

class MyTicket implements Runnable {
int tickets = 100;
public void run() {
while (true) {
if (tickets > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "窗口@销售："
+ tickets + "号票");
tickets--;

} else {
System.out.println("票已卖完。。。");
break;
}
}
}
}
public class MainTest {
public static void main(String[] args) {
MyTicket mt = new MyTicket();
Thread t1 = new Thread(mt);
Thread t2 = new Thread(mt);
Thread t3 = new Thread(mt);
Thread t4 = new Thread(mt);
t1.start();
t2.start();
t3.start();
t4.start();
}
}

五，线程的通信

线程间通信其实就是多个线程在操作同一个资源，但操作动作不同

生产者消费者

如果有多个生产者和消费者，一定要使用while循环判断标记，然后在使用notifyAll唤醒，否者容易只用notify容易出现只唤醒本方线程情况，导致程序中的所有线程都在等待。

例如：有一个数据存储空间，划分为两个部分，一部分存储人的姓名，一部分存储性别，我们开启一个线程，不停地想其中存储姓名和性别（生产者），开启另一个线程从数据存储空间中取出数据（消费者）。

由于是多线程的，就需要考虑，假如生产者刚向数据存储空间中添加了一个人名，还没有来得及添加性别，cpu就切换到了消费者的线程，消费者就会将这个人的姓名和上一个人的性别进行了输出。

还有一种情况是生产者生产了若干次数据，消费者才开始取数据，或者消费者取出数据后，没有等到消费者放入新的数据，消费者又重复的取出自己已经去过的数据。

public class Demo10 {
public static void main(String[] args) {
Person p = new Person();
Producer pro = new Producer(p);
Consumer con = new Consumer(p);
Thread t1 = new Thread(pro, "生产者");
Thread t2 = new Thread(con, "消费者");
t1.start();
t2.start();
}
}

// 使用Person作为数据存储空间
class Person {
String name;
String gender;
}

// 生产者
class Producer implements Runnable {
Person p;

public Producer() {

}

public Producer(Person p) {
this.p = p;
}

@Override
public void run() {
int i = 0;
while (true) {
if (i % 2 == 0) {
p.name = "jack";
p.gender = "man";
} else {
p.name = "小丽";
p.gender = "女";
}
i++;
}

}

}

// 消费者
class Consumer implements Runnable {
Person p;

public Consumer() {

}

public Consumer(Person p) {
this.p = p;
}

@Override
public void run() {

while (true) {
System.out.println("name:" + p.name + "---gnder:" + p.gender);
}
}

}

在上述代码中，Producer和Consumer 类的内部都维护了一个Person类型的p成员变量，通过构造函数进行赋值，在man方法中创建了一个Person对象，将其同时传递给Producer和Consumer对象，所以Producer和Consumer访问的是同一个Person对象。并启动了两个线程。

输出：



显然屏幕输出了小丽 man 这样的结果是出现了线程安全问题。所以需要使用synchronized来解决该问题。

public class Demo10 {
public static void main(String[] args) {
Person p = new Person();
Producer pro = new Producer(p);
Consumer con = new Consumer(p);
Thread t1 = new Thread(pro, "生产者");
Thread t2 = new Thread(con, "消费者");
t1.start();
t2.start();
}
}

// 使用Person作为数据存储空间
class Person {
String name;
String gender;
}

// 生产者
class Producer implements Runnable {
Person p;

public Producer() {

}

public Producer(Person p) {
this.p = p;
}

@Override
public void run() {
int i = 0;
while (true) {
synchronized (p) {
if (i % 2 == 0) {
p.name = "jack";
p.gender = "man";
} else {
p.name = "小丽";
p.gender = "女";
}
i++;
}

}

}

}

// 消费者
class Consumer implements Runnable {
Person p;

public Consumer() {

}

public Consumer(Person p) {
this.p = p;
}

@Override
public void run() {

while (true) {
synchronized (p) {
System.out.println("name:" + p.name + "---gnder:" + p.gender);
}

}
}

}

编译运行：屏幕没有再输出jack –女 或者小丽- man 这种情况了。说明我们解决了线程同步问题，但是仔细观察，生产者生产了若干次数据，消费者才开始取数据，或者消费者取出数据后，没有等到消费者放入新的数据，消费者又重复的取出自己已经去过的数据。这个问题依然存在。

升级：在Person类中添加两个方法，set和read方法并设置为synchronized的，让生产者和消费者调用这两个方法。

public class Demo10 {
public static void main(String[] args) {
Person p = new Person();
Producer pro = new Producer(p);
Consumer con = new Consumer(p);
Thread t1 = new Thread(pro, "生产者");
Thread t2 = new Thread(con, "消费者");
t1.start();
t2.start();
}
}

// 使用Person作为数据存储空间
class Person {
String name;
String gender;

public synchronized void set(String name, String gender) {
this.name = name;
this.gender = gender;
}

public synchronized void read() {
System.out.println("name:" + this.name + "----gender:" + this.gender);
}

}

// 生产者
class Producer implements Runnable {
Person p;

public Producer() {

}

public Producer(Person p) {
this.p = p;
}

@Override
public void run() {
int i = 0;
while (true) {

if (i % 2 == 0) {
p.set("jack", "man");
} else {
p.set("小丽", "女");
}
i++;

}

}

}

// 消费者
class Consumer implements Runnable {
Person p;

public Consumer() {

}

public Consumer(Person p) {
this.p = p;
}

@Override
public void run() {

while (true) {
p.read();

}
}

}

需求：我们需要生产者生产一次，消费者就消费一次。然后这样有序的循环。

这就需要使用线程间的通信了。Java通过Object类的wait，notify，notifyAll这几个方法实现线程间的通信。

等待唤醒机制如下：

wait：告诉当前线程放弃执行权，并放弃监视器（锁）并进入阻塞状态，直到其他线程持有获得执行权，并持有了相同的监视器（锁）并调用notify为止。

notify：唤醒持有同一个监视器（锁）中调用wait的第一个线程，例如，餐馆有空位置后，等候就餐最久的顾客最先入座。注意：被唤醒的线程是进入了可运行状态。等待cpu执行权。

notifyAll：唤醒持有同一监视器中调用wait的所有的线程。

如何解决生产者和消费者的问题？

可以通过设置一个标记，表示数据的（存储空间的状态）例如，当消费者读取了（消费了一次）一次数据之后可以将标记改为false，当生产者生产了一个数据，将标记改为true。

，也就是只有标记为true的时候，消费者才能取走数据，标记为false时候生产者才生产数据。

代码实现：

public class Demo10 {
public static void main(String[] args) {
Person p = new Person();
Producer pro = new Producer(p);
Consumer con = new Consumer(p);
Thread t1 = new Thread(pro, "生产者");
Thread t2 = new Thread(con, "消费者");
t1.start();
t2.start();
}
}

// 使用Person作为数据存储空间
class Person {
String name;
String gender;
boolean flag = false;

public synchronized void set(String name, String gender) {
if (flag) {
try {
wait();
} catch (InterruptedException e) {

e.printStackTrace();
}
}
this.name = name;
this.gender = gender;
flag = true;
notify();
}

public synchronized void read() {
if (!flag) {
try {
wait();
} catch (InterruptedException e) {

e.printStackTrace();
}
}
System.out.println("name:" + this.name + "----gender:" + this.gender);
flag = false;
notify();
}

}

// 生产者
class Producer implements Runnable {
Person p;

public Producer() {

}

public Producer(Person p) {
this.p = p;
}

@Override
public void run() {
int i = 0;
while (true) {

if (i % 2 == 0) {
p.set("jack", "man");
} else {
p.set("小丽", "女");
}
i++;

}

}

}

// 消费者
class Consumer implements Runnable {
Person p;

public Consumer() {

}

public Consumer(Person p) {
this.p = p;
}

@Override
public void run() {

while (true) {
p.read();

}
}

}

线程间通信其实就是多个线程在操作同一个资源，但操作动作不同，wait，notify（），notifyAll()都使用在同步中，因为要对持有监视器（锁）的线程操作，所以要使用在同步中，因为只有同步才具有锁。

为什么这些方法定义在Object类中

因为这些方法在操作线程时，都必须要标识他们所操作线程持有的锁，只有同一个锁上的被等待线程，可以被统一锁上notify唤醒，不可以对不同锁中的线程进行唤醒，就是等待和唤醒必须是同一个锁。而锁由于可以使任意对象，所以可以被任意对象调用的方法定义在Object类中

wait() 和 sleep()有什么区别？

wait():释放资源，释放锁。是Object的方法

sleep():释放资源，不释放锁。是Thread的方法

定义了notify为什么还要定义notifyAll，因为只用notify容易出现只唤醒本方线程情况，导致程序中的所有线程都在等待。

六，线程的生命周期

任何事物都是生命周期，线程也是，

1. 正常终止 当线程的run()执行完毕，线程死亡。

2. 使用标记停止线程

注意：Stop方法已过时，就不能再使用这个方法。

如何使用标记停止线程停止线程。

开启多线程运行，运行代码通常是循环结构，只要控制住循环，就可以让run方法结束，线程就结束。

class StopThread implements Runnable {
public boolean tag = true;
@Override
public void run() {
int i = 0;

while (tag) {
i++;
System.out.println(Thread.currentThread().getName() + "i:" + i);
}
}
}
public class Demo8 {
public static void main(String[] args) {
StopThread st = new StopThread();
Thread th = new Thread(st, "线程1");
th.start();
for (int i = 0; i < 100; i++) {
if (i == 50) {
System.out.println("main i:" + i);
st.tag = false;
}
}
}
}

上述案例中定义了一个计数器i，用来控制main方法（主线程）的循环打印次数，在i到50这段时间内，两个线程交替执行，当计数器变为50，程序将标记改为false，也就是终止了线程1的while循环，run方法结束，线程1也随之结束。注意：当计数器i变为50的，将标记改为false的时候，cpu不一定马上回到线程1，所以线程1并不会马上终止。

七，后台线程

后台线程：就是隐藏起来一直在默默运行的线程，直到进程结束。

实现：

setDaemon(boolean on)

特点：

当所有的非后台线程结束时，程序也就终止了同时还会杀死进程中的所有后台线程，也就是说，只要有非后台线程还在运行，程序就不会终止，执行main方法的主线程就是一个非后台线程。

必须在启动线程之前（调用start方法之前）调用setDaemon（true）方法，才可以把该线程设置为后台线程。

一旦main（）执行完毕，那么程序就会终止，JVM也就退出了。

可以使用isDaemon() 测试该线程是否为后台线程（守护线程）。

该案例：开启了一个qq检测升级的后台线程，通过while真循环进行不停检测，当计数器变为100的时候，表示检测完毕，提示是否更新，线程同时结束。

为了验证，当非后台线程结束时，后台线程是否终止，故意让该后台线程睡眠一会。发现只要main线程执行完毕，后台线程也就随之消亡了。

class QQUpdate implements Runnable {
int i = 0;

@Override
public void run() {
while (true) {

System.out.println(Thread.currentThread().getName() + " 检测是否有可用更新");
i++;
try {
Thread.sleep(10);
} catch (InterruptedException e) {

e.printStackTrace();
}
if (i == 100) {
System.out.println("有可用更新，是否升级？");
break;
}
}
}
}
public class Demo9 {
public static void main(String[] args) {
QQUpdate qq = new QQUpdate();
Thread th = new Thread(qq, "qqupdate");
th.setDaemon(true);
th.start();
System.out.println(th.isDaemon());
System.out.println("hello world");
}
}

Thread的join方法

当A线程执行到了B线程Join方法时A就会等待，等B线程都执行完A才会执行，Join可以用来临时加入线程执行

本案例，启动了一个JoinThread线程，main（主线程）进行for循环，当计数器为50时，让JoinThread，通过join方法，加入到主线程中，发现只有JoinThread线程执行完，主线程才会执行完毕.

可以刻意让JoinThread线程sleep，如果JoinThread没有调用join方法，那么肯定是主线程执行完毕，但是由于JoinThread线程加入到了main线程，必须等JoinThread执行完毕主线程才能继续执行。

class JoinThread implements Runnable {

@Override
public void run() {
int i = 0;
while (i < 300) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " i:" + i);
i++;
}
}
}

public class Demo10 {
public static void main(String[] args) throws InterruptedException {
JoinThread jt = new JoinThread();
Thread th = new Thread(jt, "one");
th.start();
int i = 0;
while (i < 200) {
if (i == 100) {
th.join();
}
System.err.println(Thread.currentThread().getName() + " i:" + i);
i++;

}
}
}

上述程序用到了Thread类中的join方法，即th.join语句，作用是将th对应的线程合并到嗲用th.join语句的线程中，main方法的线程中计数器到达100之前，main线程和one线程是交替执行的。在main线程中的计数器到达100后，只有one线程执行，也就是one线程此时被加进了mian线程中，one线程不执行完，main线程会一直等待

带参数的join方法是指定合并时间，有纳秒和毫秒级别。

八，创建线程的方式三：

通过Callable和Future创建线程

（1）创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值。

（2）创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。

（3）使用FutureTask对象作为Thread对象的target创建并启动新线程。

（4）调用FutureTask对象的get()方法来获得子线程执行结束后的返回值

实例代码：

public class CallableThreadTest implements Callable<Integer>
{

public static void main(String[] args)
{
CallableThreadTest ctt = new CallableThreadTest();
FutureTask<Integer> ft = new FutureTask<>(ctt);
for(int i = 0;i < 100;i++)
{
System.out.println(Thread.currentThread().getName()+" 的循环变量i的值"+i);
if(i==20)
{
new Thread(ft,"有返回值的线程").start();
}
}
try
{
System.out.println("子线程的返回值："+ft.get());
} catch (InterruptedException e)
{
e.printStackTrace();
} catch (ExecutionException e)
{
e.printStackTrace();
}

}

@Override
public Integer call() throws Exception
{
int i = 0;
for(;i<100;i++)
{
System.out.println(Thread.currentThread().getName()+" "+i);
}
return i;
}

}

九，创建线程的三种方式的对比

采用实现Runnable、Callable接口的方式创见多线程时，优势是：

线程类只是实现了Runnable接口或Callable接口，还可以继承其他类。

在这种方式下，多个线程可以共享同一个target对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU、代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。

劣势是：

编程稍微复杂，如果要访问当前线程，则必须使用Thread.currentThread()方法。

使用继承Thread类的方式创建多线程时优势是：

编写简单，如果需要访问当前线程，则无需使用Thread.currentThread()方法，直接使用this即可获得当前线程。

劣势是：

线程类已经继承了Thread类，所以不能再继承其他父类。