线程简述
1.线程的相关概念
2.线程的创建和启动 ★
3.线程的停止
4.线程的常见方法(Thread)
5.线程的生命周期 ★
6.线程的同步
7.线程的通信
线程的相关概念
概念
程序:为了让计算机完成某个特定的功能,编写的一系列有序指令的集合。
实则是一段静止的代码段
进程:正在运行的程序,它有自己的生命周期
线程:轻量级的进程。一个进程可以划分为若干个执行单位,每个执行单位可以看做是一个线程
一个进程可以包含多个线程
比如:正在运行的qq
它也有自己的生命周期
单线程:一个进程中,在同一个时刻,只能运行一个线程,必须等待该线程执行结束,其他线程才能开始执行
多线程:一个进程中,在同一个时刻,可以同时运行多个线程
单核cpu: 仅仅只是貌似 “同时”
多核cpu: 有可能出现真正“同时”
比如:qq 同时打开多个线程,打开qq新闻、打开qq聊天窗口
多线程的好处
1、有效的占用了cpu的空闲时间,从一定程度上提高了效率
2、提高了用户的体验性
3、将一个复杂的进程拆分成若干个小的线程,提高代码的分离性和维护性
线程的创建和启动
方式一:继承Thread
定义线程类:
class MyThread extends Thread{
public void run(){
//编写新线程要执行的任务体
}
}
创建新线程,并启动
new MyThread().start();
方式二:实现Runnable
定义任务类:
class MyRunnable implements Runnable{
public void run(){
//编写新线程的任务体
}
}
创建新线程,并启动
new Thread(new MyRunnable()).start();
两种方式的对比★
1、方式二避免了单继承的局限性,使用更加灵活
2、方式二更适合处理多线程共享资源的情况
线程的停止
1.stop 已经过时
2.Interrupt 只能中断睡眠、等待这些状态,会抛出InterruptedException异常,并没有真正的结束线程
3.采用通知的方法 ★
步骤1:让需要停止的线程中添加一个循环标记,默认值为true
步骤2:让需要停止的线程中添加一个公共的set方法,用于更新循环标记
步骤3:需要停止该线程时,调用set方法即可
线程的常见方法 【了解】
currentThread 获取当前线程对象
setName设置线程名称
getName获取线程名称
setPriority设置线程优先级1——10
getPriority获取线程优先级
sleep休眠
interrupt中断休眠状态
yield线程的礼让
join线程的插队
setDaemon设置守护线程
线程的生命周期
线程的同步
理解
线程的同步实际上就是线程的安全问题。如果多个线程处理共享资源时,出现了数据安全问题,称为线程的同步问题!
线程的同步如何发生的?
当多条语句在操作同一个线程共享数据时,一个线程对多条语句只执行了一部分,还没有执行完,另一个线程参与进来执行。导致共享数据的错误
如何避免线程的同步问题?
对多条操作共享数据的语句,只能让一个线程都执行完,在执行过程中,其他线程不可以参与执行
借鉴:火车厢的洗手间的上锁的方式
线程的同步的实现方式 ★
对象+synchronized 搭配使用
方式一:同步代码块
synchronized(锁对象){
//需要上锁的代码(同步的代码)
}
方式二:同步方法
public synchronized 返回类型 方法名(参数列表){
//需要上锁的代码(同步的代码)
}
注意:
普通的同步方法,锁对象是:this
静态的同步方法,锁对象是:当前类.class
要求:
多个线程使用的锁对象必须是同一个!!!
线程的同步前提
1、多线程
2、有共享资源&线程的任务体中有对共享资源处理语句
使用同步的落地步骤 ★
1、先分析需要上锁的代码
2、分析需要同步代码块还是同步方法
3、检测多线程使用的锁对象是否为同一个!!!
线程的死锁
发生原因:多个线程都需要用到多把锁,每一个线程都需要对方线程的锁对象,如果多个线程互不相让,导致死锁问题
线程的通信
理解
线程的通信也就是 线程之间的 “交流”,也就是通过一定的方法,实现线程的控制!
相关的API ★
一、wait
语法:
锁对象.wait();
特点:
1、让当前线程等待,直到其他线程调用了该锁对象的notify或notifyAll方法为止,否则将一直等待
2、wait的调用 必须在同步的前提下
3、wait的调用 会导致锁的释放
4、如果等待结束也就是被唤醒后,则继续从断点处往下执行!
二、notify和notifyAll
语法:锁对象.notify()|notifyAll();
特点:
1、notify:唤醒当前锁对象下等待的单个线程。优先级较高的优先唤醒,如果优先级一样,则随机
notifyall:唤醒当前锁对象下所有等待的线程
2、notify和notifyAll的调用,必须在同步的前提下
注意:
wait、notify、notifyAll和当前同步代码的锁对象都必须是同一个!否则报异常!!!!
线程详解
一、相关概念
程序:一段静止的代码
进程:正在运行的程序,有自己的生命周期
线程:轻量级的进程,一个进程可以包含为多个线程
单线程:一个进程中,同一个时刻,只允许运行一个线程,在运行期间,其他线程只能等待,只有该线程运行结束,其他线程才能开始
多线程:一个进程中,同一个时刻,可以同时运行多个线程
机制:多个线程不断交替的抢占cpu占用权,因为切换的频率非常快,造成“同时”的现象
二、多线程的好处
1、有效的占用了cpu的空闲时间,从一定程度上提高了效率
2、提高了用户体验性
3、将一个复杂的进程拆分成若干个小的线程,提高了代码的分离性和维护性
三、多线程的应用场景
1、程序中需要同时执行两个或多个任务
2、程序中用到了耗时操作,如网络下载、用户输入等
3、需要后台做一些操作
线程的创建与启动
一、继承Thread类方式
定义:
class A extends Thread{
public void run(){
//编写任务体
}
}
创建并启动:
A a = new A();
a.start();
二、实现Runnable接口方式
定义:
class A implements Runnable{
public void run(){
//编写任务体
}
}
创建并启动:
A a = new A();
new Thread(a).start();
此处不能调用run方法
三、实现Callable接口方式
定义:
class A implements Callable<String>{
public String call() throws Exception{
//编写任务体
}
}
创建并启动:
FutureTask futureTask = new FutureTask(new MyThread03());
new Thread(futureTask).start();
Integer i= futureTask.get();
四、线程池
//1.调用Executors的newFixedThreadPool(),返回指定线程数量的ExecutorService
ExecutorService pool = Executors.newFixedThreadPool(10);
//2.将Runnable实现类的对象作为形参传递给ExecutorService的submit()方法中,开启线程
//并执行相关的run()
pool.submit(new MyThread());//线程.start()
pool.submit(new MyThread());
pool.submit(new MyThread());
//3.结束线程的使用
pool.shutdown();
实现Runnable接口和继承Thread的区别:
1.使用实现Runnable接口的方式,更加灵活,避免了单继承的局限性
2.使用实现Runnable接口的方式,更加适合解决处理共享资源的情况
实现Callable接口和实现Runnable接口的区别:
1、实现Callable接口的方式,方法有返回值
实现Runnable接口的方式,方法没有返回值
2、实现Callable接口的方式,call方法可以抛出异常
实现Runnable接口的方式,run方法不会抛出异常
线程的停止
1、调用Thread类的stop方法
已经过时,不推荐使用
2、调用Thread类的Interrupt方法
中断sleep、wait、join状态,会抛一个InterrupttedException
3、采用通知的方式
步骤一:需要停止的线程内部,定义一个循环变量标记,默认值为true
步骤二:需要停止的线程内部,定义一个公共的设置循环变量标记的方法set
步骤三:需要停止线程时,调用set方法,更新标记值为false
线程的生命周期
新建:创建了线程对象,但没有调用start方法
就绪:调用了start方法,但没有抢占到cpu占用权
运行:抢占到了cpu占用权
死亡:线程正常执行结束|error或Exception意外退出|break或return正常退出
堵塞:在运行状态期间调用了 sleep|wait|join。当sleep时间到或调用了notify等,也会从堵塞状态切换到就绪状态
线程的常用方法
setName
getName
setPriority
getPriority
sleep
interrupt
join
yield
setDaemon
currentThread
线程的同步
一、线程的同步问题发生原因
当有多条语句处理共享资源,其中一个线程执行了一部分,但没执行完,其他线程参与进来,导致线程出现安全问题
二、如何解决线程的同步问题
当有多条语句处理共享资源,其中一个线程执行结束后,其他线程再参与进来
需要“上锁”!
三、线程的同步的实现方式
对象+synchronized 可以实现
方式一:使用同步代码块
synchronized(锁对象){
//需要同步的代码
}
方式二:使用同步方法
public synchronized 返回类型 方法名(参数列表){
//需要同步的代码
}
注意:
普通同步方法,锁对象:this
静态同步方法,锁对象:类.class
四、线程同步实现的落地步骤
1.先分析需要上锁的代码
2.选择同步代码块或同步方法上锁
3.检测多个线程使用的锁对象是同一个!
五、总结释放锁和不释放锁的操作
一)释放锁
1、线程正常执行结束
2、遇到return或break
3、error或Exception
4、调用了wait
二)不会释放锁
1、sleep
2、yield
3、suspend【了解】
线程通信
一、理解
线程通信即实现线程的“交流”
通过一定的方法,实现线程的控制
二、相关API
1、wait
语法:
锁对象.wait()
特点:
①导致当前线程等待,一直到被notify或notifyAll为止
②调用wait方法,必须在同步前提下
③调用wait方法,会导致锁的释放
④wait方法调用后,被唤醒,将从断点处继续往下执行!
2、notify
语法:
锁对象.notify()
特点:
①唤醒当前锁对象下等待的单个线程,如果多个线程都在等待,优先唤醒优先级较高的,如果优先级一样,则随机
②调用notify方法,必须在同步前提下
3、notifyAll
语法:
锁对象.notifyAll()
特点:
①唤醒当前锁对象下等待的所有线程
②调用notify方法,必须在同步前提下
三、线程通信的落地步骤
1、需要先将代码实现同步
2、根据需要,调用wait或notify 、notifyAll ★
3、检测wait、notify、notifyAll的调用者和同步的锁对象是否是同一个
线程图解
程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码,静态对象。
进程(process)是程序的一次执行过程,或是正在运行的一个程序。动态过程:有它自身的产生、存在和消亡的过程。
如:运行中的QQ,运行中的MP3播放器
程序是静态的,进程是动态的
线程(thread),进程可进一步细化为线程,是一个程序内部的一条执行路径。
若一个程序可同一时间执行多个线程,就是支持多线程的
进程与多线程
每个Java程序都有一个隐含的主线程: main 方法
使用多线程的优点
背景:只使用单个线程完成多个任务(调用多个方法),肯定比用多个线程来完成用的时间更短,为何仍需多线程呢?
多线程程序的优点:
提高应用程序的响应。对图形化界面更有意义,可增强用户体验。
提高计算机系统CPU的利用率
改善程序结构。将既长又复杂的进程分为多个线程,独立运行,利于理解和修改
何时需要多线程
程序需要同时执行两个或多个任务。
程序需要实现一些需要等待的任务时,如用户输入、文件读写操作、网络操作、搜索等。
需要一些后台运行的程序时。
线程的创建和启动
public class Sample {
public void method1(String str){
System.out.println(str);
}
public void method2(String str){
method1(str);
}
public static void main(String[] args) {
Sample s = new Sample();
s.method2("hello!");
}
}
Java语言的JVM允许程序运行多个线程,它通过java.lang.Thread类来实现。
Thread类的特性
每个线程都是通过某个特定Thread对象的run()方法来完成操作的,经常把run()方法的主体称为线程体
通过该Thread对象的start()方法来调用这个线程
mt子线程的创建和启动过程
Thread类
构造器
Thread():创建新的Thread对象
Thread(String threadname):创建线程并指定线程实例名
Thread(Runnable target):指定创建线程的目标对象,它实现了Runnable接口中的run方法
Thread(Runnable target, String name):创建新的Thread对象
创建线程的两种方式
继承Thread类
- 定义子类继承Thread类。
- 子类中重写Thread类中的run方法。
- 创建Thread子类对象,即创建了线程对象。
- 调用线程对象start方法:启动线程,调用run方法。
实现Runnable接口
1.定义子类,实现Runnable接口。
2.子类中重写Runnable接口中的run方法。
3.通过Thread类含参构造器创建线程对象。
4.将Runnable接口的子类对象作为实际参数传递给
Thread类的构造器中。
5.调用Thread类的start方法:开启线程,调用
Runnable子类接口的run方法。
继承方式和实现方式的联系与区别
【区别】
继承Thread: 线程代码存放Thread子类run方法中。
实现Runnable:线程代码存在接口的子类的run方法。
【实现方法的好处】
1)避免了单继承的局限性
2)多个线程可以共享同一个接口子类的对象,非常适合多个相同线程来处理同一份资源。
Thread类的有关方法
void start(): 启动线程,并执行对象的run()方法
run(): 线程在被调度时执行的操作
String getName(): 返回线程的名称
void setName(String name):设置该线程名称
static currentThread(): 返回当前线程
线程的调度
线程的优先级
线程的优先级控制
MAX_PRIORITY(10);
MIN _PRIORITY (1);
NORM_PRIORITY (5);
涉及的方法:
getPriority() :返回线程优先值
setPriority(int newPriority) :改变线程的优先级
线程创建时继承父线程的优先级
Thread类的有关方法
static void yield():线程让步
暂停当前正在执行的线程,把执行机会让给优先级相同或更高的线程
若队列中没有同优先级的线程,忽略此方法
join() :当某个程序执行流中调用其他线程的 join() 方法时,调用线程将被阻塞,直到 join() 方法加入的 join 线程执行完为止
低优先级的线程也可以获得执行
static void sleep(long millis):(指定时间:毫秒)
令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后重排队。
抛出InterruptedException异常
stop(): 强制线程生命期结束
boolean isAlive():返回boolean,判断线程是否还活着
线程的分类
Java中的线程分为两类:一种是守护线程,一种是用户线程。
它们在几乎每个方面都是相同的,唯一的区别是判断JVM何时离开。
守护线程是用来服务用户线程的,通过在start()方法前调用thread.setDaemon(true)可以把一个用户线程变成一个守护线程。
Java垃圾回收就是一个典型的守护线程。
若JVM中都是守护线程,当前JVM将退出。
JDK中用Thread.State枚举表示了线程的几种状态
要想实现多线程,必须在主线程中创建新的线程对象。Java语言使用Thread类及其子类的对象来表示线程,在它的一个完整的生命周期中通常要经历如下的五种状态:
新建: 当一个Thread类或其子类的对象被声明并创建时,新生的线程对象处于新建状态
就绪:处于新建状态的线程被start()后,将进入线程队列等待CPU时间片,此时它已具备了运行的条件
运行:当就绪的线程被调度并获得处理器资源时,便进入运行状态, run()方法定义了线程的操作和功能
阻塞:在某种特殊情况下,被人为挂起或执行输入输出操作时,让出 CPU 并临时中止自己的执行,进入阻塞状态
死亡:线程完成了它的全部工作或线程被提前强制性地中止
问题的提出
多个线程执行的不确定性引起执行结果的不稳定
多个线程对账本的共享,会造成操作的不完整性,会破坏数据。
模拟火车站售票程序,开启三个窗口售票。
class Ticket implements Runnable{
private int tick = 100;
public void run(){
while(true){
if(tick>0){
System.out.println(Thread.currentThread().getName()+“售出车票,tick号为:"+ tick--);
}
else
break;
}
}
}
class TicketDemo{
public static void main(String[] args) {
Ticket t = new Ticket();
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
Thread t3 = new Thread(t);
t1.setName("t1窗口");
t2.setName("t2窗口");
t3.setName("t3窗口");
t1.start();
t2.start();
t3.start();
}
}
private int tick = 100;
public void run(){
while(true){
if(tick>0){
try{
Thread.sleep(10);
}catch(InterruptedException e){ e.printStackTrace();}
System.out.println(Thread.currentThread().getName()+“售出车票,tick号为:
"+tick--);
} } }
多线程出现了安全问题
问题的原因:
当多条语句在操作同一个线程共享数据时,一个线程对多条语句只执行了一部分,还没有执行完,另一个线程参与进来执行。导致共享数据的错误。
解决办法:
对多条操作共享数据的语句,只能让一个线程都执行完,在执行过程中,其他线程不可以参与执行。
Synchronized的使用方法
Java对于多线程的安全问题提供了专业的解决方式:
同步代码块
synchronized (对象){
// 需要被同步的代码;
}
synchronized还可以放在方法声明中,表示整个方法
为同步方法。
例如:
public synchronized void show (String name){
….
}
分析同步原理
同步锁(Lock)
从Java 5开始,Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。
Lock是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问,每次只能有一个线程对Lock对象加锁,线程开始访问共享资源之前应先获得Lock对象。
在实现线程安全的控制中,比较常用的是ReentrantLock(可重入锁),可以显式加锁、释放锁。
class A{
private final ReentrantLock lock = new ReenTrantLock();
public void m(){
lock.lock();
try{
//保证线程安全的代码;
}
finally{
lock.unlock(); }}}
互斥锁
在Java语言中,引入了对象互斥锁的概念,来保证共享数据操作的完整性。
每个对象都对应于一个可称为“互斥锁”的标记,这个标记用来保证在任一时刻,只能有一个线程访问该对象。
关键字synchronized 来与对象的互斥锁联系。当某个对象用synchronized修饰时,表明该对象在任一时刻只能由一个线程访问。
同步的局限性:导致程序的执行效率要降低
同步方法(非静态的)的锁为this。
同步方法(静态的)的锁为当前类本身。
单例设计模式之懒汉式
class Singleton {
private static Singleton instance = null;
private Singleton(){}
public static Singleton getInstance(){
if(instance==null){
synchronized(Singleton.class){
if(instance == null){
instance=new Singleton();
} } }
return instance;
} }
public class TestSingleton{
public static void main(String[] args){
Singleton s1=Singleton.getInstance();
Singleton s2=Singleton.getInstance();
System.out.println(s1==s2);
} }
小结:释放锁的操作
当前线程的同步方法、同步代码块执行结束
当前线程在同步代码块、同步方法中遇到break、return终止了该代码块、该方法的继续执行。
当前线程在同步代码块、同步方法中出现了未处理的Error或Exception,导致异常结束
当前线程在同步代码块、同步方法中执行了线程对象的wait()方法,当前线程暂停,并释放锁。
小结:不会释放锁的操作
线程执行同步代码块或同步方法时,程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行
线程执行同步代码块时,其他线程调用了该线程的suspend()方法将该线程挂起,该线程不会释放锁(同步监视器)。
应尽量避免使用suspend()和resume()来控制线程
线程的死锁问题
死锁
不同的线程分别占用对方需要的同步资源不放弃,都在等待对方放弃自己需要的同步资源,就形成了线程的死锁
解决方法
专门的算法、原则
尽量减少同步资源的定义
public class TestDeadLock {
public static void main(String[] args) {
final StringBuffer s1 = new StringBuffer();
final StringBuffer s2 = new StringBuffer();
new Thread() {
public void run() {
synchronized (s1) {
s2.append("A");
synchronized (s2) {
s2.append("B");
System.out.print(s1);
System.out.print(s2);
}}}}.start();
new Thread() {
public void run() {
synchronized (s2) {
s2.append("C");
synchronized (s1) {
s1.append("D");
System.out.print(s2);
System.out.print(s1);
}}}}.start();
}}
wait() 与 notify() 和 notifyAll()
wait():令当前线程挂起并放弃CPU、同步资源,使别的线程可访问并修改共享资源,而当前线程排队等候再次对资源的访问
notify():唤醒正在排队等待同步资源的线程中优先级最高者结束等待
notifyAll ():唤醒正在排队等待资源的所有线程结束等待.
Java.lang.Object提供的这三个方法只有在synchronized方法或synchronized代码块中才能使用,否则会报java.lang.IllegalMonitorStateException异常
wait() 方法
在当前线程中调用方法: 对象名.wait()
使当前线程进入等待(某对象)状态 ,直到另一线程对该对象发出 notify (或notifyAll) 为止。
调用方法的必要条件:当前线程必须具有对该对象的监控权(加锁)
调用此方法后,当前线程将释放对象监控权 ,然后进入等待
在当前线程被notify后,要重新获得监控权,然后从断点处继续代码的执行。
notify()/notifyAll()
在当前线程中调用方法: 对象名.notify()
功能:唤醒等待该对象监控权的一个线程。
调用方法的必要条件:当前线程必须具有对该对象的监控权(加锁)
例题:使用两个线程打印 1-100. 线程1, 线程2 交替打印
class Communication implements Runnable{
int i = 1;
public void run() {
while (true) {
synchronized (this) {
notify();
if (i <= 100) {
System.out.println(Thread.currentThread().getName() + ":"
+ i++);
}
else break;
try {
wait();} catch (InterruptedException e) {
}}}}}
系统启动一个新线程的成本是比较高的,因为它涉及与os交互。这种情况下,系统启动时即创建大量空闲的线程,就可以很好地提高性能,尤其是当程序需要创建大量生存期很短暂的线程时。
除此之外,使用线程池可以有效地控制系统中并发线程的数量。避免因并发创建的线程过多,导致系统性能下降,JVM崩溃。
Java 5以前,需要手动创建自己的线程池;Java 5开始,新增了Executors工厂类产生线程池。
使用线程池执行线程任务的步骤如下:
1.调用Executors 类的静态方法newFixedThreadPool(int nThreads),创建一个可重用的、具有固定线程数的线程池ExecutorService对象
2.创建Runnable实例,作为线程执行任务
3.调用ExecutorService对象的submit()提交Runnable实例
4.调用ExecutorService对象的shutDown()方法关闭线程池。
若读者想要了解关于Java多线程经典例题请查看我的下一篇博客:Java线程经典面试题,不喜勿喷~