文章标题多线程概述和基本使用

一、概念

进程：一个应用程序启动，就说一个进程启动。进程是计算机进行资源分配的基本单位

线程：程序运行过程中的最小执行单位。一个进程可以包含多个线程。

程序：静态概念。

多线程的目的：最大限度的利用cpu的资源，提高程序运行效率。

二、线程

面向对象的编程：

1.抽象：对象所具有的共有的特征和行为

class Thread{

void run(){

//指明线程所要执行的过程，流程。

}

void start();

}

new Thread().start();

三、线程三要素：

1.cpu ： 软件cpu 共享

2.code ：

3.Data

四、多线程的机制：

1. java.lang.Thread{

void run(){

//指定当前线程所要完成的任务。

}

void start();用来给cpu发送执行信号，当这个方法执行就代表告诉cpu当前线程准备就绪，可以执行。

}

2.java中多线程的实现方式：

1) extends Thread:

class SubThread extends Thread{

public void run(){

//….

}

}

new SubThread().start();

2) implements Runnable:

class SubRunnable implements Runnable{

public void run(){

//…..

}

}

SubRunnable sr = new SubRnnable();

new Thread(sr).start();

3.两种方式的比较。

java不能多继承

class Father{}

class Son extends Father{}

五、线程状态间的转换：

1.初始状态(新建状态)

刚刚使用new关键字创建出来的线程对象。

2.就绪状态：

新建的线程对象调用start方法之后就进入就绪状态。称之为准备好了的状态(万事俱备只欠东风)。只等cpu调度。

如果对一个已经处于就绪状态的线程再次调用start方法，报错

进入到就绪状态的线程脱离程序员控制(谁先执行，谁后执行，是否交替等都由cpu决定。)

3.运行状态

一个处于就绪状态的线程被cpu调度了，就进入执行状态，开始执行run方法。

cpu调度：时间片轮换

如果时间片到了，保存当前正在执行的线程的状态，将线程送回到runnable状态，再次参与cpu时间片轮换。

4.阻塞状态

1.挂起：

1） 正在运行的线程调用sleep方法会放弃cpu的使用权利，进入到阻塞状态,不参与cpu抢占。不会释放拥有的资源。

正在sleep的线程timeout，或者被interrupt，那么会终止阻塞，进入到Runnable状态。

interrupt：中断线程(发送中断信号)

isInterrupted:判断线程的中断状态。

interrupted：static修饰的方法。判断线程的中断状态，同时清空中断信息。

2） 正在运行的线程调用其他线程的join方法之后，就放弃cpu的使用权，进入到阻塞状态，等到调用了join方法的线程执行结束之后再回到runnable状态参与cpu的轮换。这时进入阻塞状态的线程也不会放弃锁资源。

谁调用谁等待，调用谁等待谁

main{

rt1.join();

rt2.join();

}

main线程会等待rt1和rt2线程执行结束之后再执行。

2.锁池：

一个正在运行的线程遇见synchronized操作，需要申请锁资源，进入阻塞状态（对象的锁池）。不参与cpu的轮换。直到申请的锁资源可用，进入runnable状态。

3.等待池

正在运行的线程遇见wait操作，放弃cpu，进入阻塞状态(等待)，进入阻塞状态的线程不再持有锁资源。等到notify/notifyAll，出wait状态，进入锁池等待

5.死亡状态：

当线程的run方法执行结束，线程进入死亡状态。进入死亡状态的线程是没办法转变成其他的状态。

控制线程的死亡：

1.stop：不推荐，不安全

2.interrupt: 中断线程，不推荐，会清除我们的中断状态，并收到一个中断异常。后续调用isInterrupted（）和interrupted（）方法判断状态时得不到正确的值。

3.设置标示变量。

共享标示：也可以用volatile来修饰该变量

//volatile保证了线程可以正确的读取其他线程写入的值

volatile boolean keepRunning = true;

1.extends Thread{

static 类变量

}

2.implements Runnable{

1.共享runnable:

1.实例变量

2.类变量

2.不同享Runnable：

2.类变量

}

start()

1.new ———> Runnable

cpu调度

2.runnable <——–>running

run完成

3.running ————-> Dead

sleep/join timeout/interrupt/joins

4.running ———->Block——————–>runnable

不释放锁资源

synchronized 申请的锁资源可用

5.running————-》阻塞—————–>runnable;

wait notify/notifyAll lock可用

6.running—->阻塞—————>锁池等待——>runnable

六、多线程并发访问的互斥问题。

java中每一个对象都有唯一的一把锁

临界区：操作共有数据时有可能会引起数据不一致结果的代码。

解决方案：

1.共有数据

2.找临界区

3.申请共有资源的锁。

note:对于临界区的控制越精确，线程的并发访问效率就越高。

1.synchronized ：

1.方法体：{

1.实例方法

申请当前对象的锁

2.静态方法

申请镜像对象的锁

}

2.代码块：

synchronized( 公有对象 ){

}

七、并发访问线程之间的通信问题。

多个并发访问的线程谁先执行谁后执行。wait，notify/notifyAll

解决思路：

1.判断谁wait，谁notify

2.控制wait在notify(notifyAll)执行之前执行。

3.找到共有数据，基于共有数据的wait以及notify

八、死锁:

多个并发的线程出现资源的相互等待。

九、线程调度：

1.yield：线程让步,给调度程度发送一个暗示，当前线程要放弃cpu。然后直接回到runnable状态，参与cpu的轮换。

2.线程都具有等级，java将线程划分为1–10个等级。值越大等级越高，一般说高等级的线程比低等级的线程具有更高的执行概率。

扩展学习：

Happens-before原则

Locks和Condition对象，是对锁机制和等待条件的高层实现

线程的安全性：原子性和可见性

DeadLocks

多线程编程常用的交互模型:Producer-Consumer模型

Read-Write Lock模型

Future模型

Worker Thread模型

了解java5引入的并发编程工具：java.util.concurrent

线程池ExcutorService

Callable & Future

BlockingQueue