Java多线程技术
线程和进程
程序Program
程序是一段静态的代码,它是应用程序执行的蓝本
进程Process
进程是指一种正在运行的程序,有自己的地址空间。
进程的特点
动态性
并发性
独立性
并发和并行的区别
并行:多个CPU执行多个CPU任务
并发:一个CPU(采用时间片)同时执行多个任务
线程Thread
进程内部的一个执行单元,它是程序中一个单一的顺序控制流程。
线程又被称为轻量级进程(lightweight process)
如果在一个进程中同时运行了多个线程,用来完成不同的工作,则称之为多线程
线程特点
轻量级进程
独立调度的基本单位
共享进程资源
可并发执行
线程和进程的区别
区别 | 进程 | 线程 |
根本区别 | 作为资源分配的单位 | 调度和执行的单位 |
开 销 | 每个进程都有独立的代码和数据空间(进程上下文),进程间的切换会有较大的开销。 | 线程可以看成时轻量级的进程,同一类线程共享代码和数据空间,每个线程有独立的运行栈和程序计数器(PC),线程切换的开销小。 |
所处环境 | 在操作系统中能同时运行多个任务(程序) | 在同一应用程序中有多个顺序流同时执行 |
分配内存 | 系统在运行的时候会为每个进程分配不同的内存区域 | 除了CPU外,不会为线程分配内存(线程所使用的资源是它所属的进程的资源),线程组只能共享资源 |
包含关系 | 没有线程的进程是可以被看作单线程的,如果一个进程内拥有多个线程,则执行过程不是一条线的,而是多条线(线程)共同完成的。 | 线程是进程的一部分,所以线程有的时候被称为是轻权进程或者轻量级进程。 |
线程定义和创建
使用多线程实现赛跑
public class Test{
public static void main(String[] args) {
//创建一个线程
Student student = new Student();
//启动一个线程
//thread.run();这不是在启动线程,是在调用方法run()
//启动线程,不见得立刻执行,而是进入就绪队列,等待获得CPU
student.start();
//小刚也在跑
for(int i = 0; i < 100; i++){
System.out.println("小刚现在领先了,加油! 当前线程的名称: " + Thread.currentThread().getName());
}
}
}
class Student extends Thread{
public void run(){
for(int i = 0; i < 100; i++){
System.out.println("小明现在领先了,加油! 当前线程的名称: " + this.getName());
}
}
}
run() 线程体,线程要完成的任务
start() 启动线程,线程进入就绪队列,等待获取CPU并执行
实现Runnable接口
public class Test{
public static void main(String[] args) {
//创建线程对象
Runnable runnable = new Student();
Thread thread = new Thread(runnable);
//启动线程
thread.start();
for(int i = 0; i < 100; i++){
System.out.println("小刚领先了,加油 当前线程的名称:" + Thread.currentThread().getName());
}
}
}
class Student implements Runnable{
@Override
public void run() {
for(int i = 0; i < 100; i++){
System.out.println("小明领先了,加油! 当前线程的名称:" + Thread.currentThread().getName());
}
}
}
两种方式的优缺点
方式1:继承Thread类
缺点:Java单继承,无法继承其他类
优点:代码稍微简单
方式2:实现Runnable接口
优点 还可以去继承其他类 便于多个线程共享同一个资源
缺点:代码略有繁琐
实际开发中,Runnable使用更多一些
方法介绍
currentThread()
返回对当前正在执行的线程对象的引用。
getName()
返回该线程的名称
getPriority()
返回线程的优先级。
run()
果该线程是使用独立的 Runnable 运行对象构造的,则调用该 Runnable 对象的 run 方法;否则,该方法不执行任何操作并返回。
setName(String name)
改变线程名称,使之与参数 name 相同。
setPriority(int newPriority)
更改线程的优先级。
start()
使该线程开始执行;Java 虚拟机调用该线程的 run 方法。
Callable接口
JDK1.5后推出了第三种定义线程的方式,实现Callable接口
使用多线程获取随机数
public class Test implements Callable<Integer> {
public static void main(String[] args) throws ExecutionException, InterruptedException {
//创建线程对象
Callable<Integer> callable = new Test();
FutureTask<Integer> futureTask = new FutureTask<Integer>(callable);
Thread thread = new Thread(futureTask);
//启动线程
thread.start();
//获取返回值
System.out.println(futureTask.isDone());
//必须等线程执行完毕后,才能得到返回值,线程在此会阻塞
Integer num = futureTask.get();
System.out.println(num);
System.out.println(futureTask.isDone());
}
@Override
public Integer call() throws Exception {
Thread.sleep(500);
return new Random().nextInt(10);
}
}
与Runnable相比, Callable功能更强大些
方法名不同
可以有返回值,支持泛型的返回值
可以抛出检查异常
需要借助FutureTask,比如获取返回结果
Future接口
可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等
FutrueTask是Futrue接口的唯一的实现类
FutureTask 同时实现了Runnable, Future接口。它既可以作为Runnable被线程执行,又可以作为Future得到Callable的返回值
新生状态
用new关键字建立一个线程对象后,该线程对象就处于新生状态。
处于新生状态的线程有自己的内存空间,通过调用start进入就绪状态
就绪状态
处于就绪状态线程具备了运行条件,但还没分配到CPU,处于线程就绪队列,等待系统为其分配CPU
当系统选定一个等待执行的线程后,它就会从就绪状态进入执行状态,该动作称之为“cpu调度”
运行状态
在运行状态的线程执行自己的run方法中代码,直到等待某资源而阻塞或完成任务而死亡。
如果在给定时间片内没执行结束,就会被系统给换下来回到等待执行状态。
阻塞状态
处于运行状态的线程在某些情况下,如执行了sleep(睡眠)方法,或等待I/O设备等资源,将让出CPU并暂时停止自己的运行,进入阻塞状态。
在阻塞状态的线程不能进入就绪队列。只有当引起阻塞的原因消除时,如睡眠时间已到,或等待的I/O设备空闲下来,线程便转入就绪状态,重新到就绪队列中排队等待,被系统选中后从原来停止的位置开始继续运行。
死亡状态
死亡状态是线程生命周期中最后一个阶段。线程死亡原因有三个。一个是正常运行的线程完成了它的全部工作;另一个是线程被强制性地终止,如通过执行stop方法来终止一个线程[不推荐使用】,三是线程抛出未捕获的异常
线程控制
理解了线程生命周期的基础上,可以使用Java提供的线程控制命令对线程的生命周期进行干预。
实际开发中经常使用Thread.sleep()来模拟线程切换,暴露线程安全问题。
join ()
阻塞指定线程等到另一个线程完成以后再继续执行
public class Test {
public static void main(String[] args){
int j = 1;
for(int i = 0; i < 100; i++){
if(i == 50){
Thread thread = new Student();
thread.setName("关云长");
thread.start();
try {
// 线程A正在执行 线程B进来,线程B执行完,A才会执行。
//A此间处于阻塞状态
thread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("小刚领先了,加油! 当前线程名: " + Thread.currentThread().getName() + j++);
}
}
}
class Student extends Thread{
int j = 1;
public void run(){
for(int i = 0; i < 100; i++){
System.out.println("小明领先了,加油! 当前线程名: " + this.getName() + j++);
}
}
}
sleep()
使线程停止运行一段时间,让出CPU,将处于阻塞状态如果调用了sleep方法之后,没有其他等待执行的线程,这个时候当前线程不会马上恢复执行!
public class Test {
public static void main(String[] args){
Thread thread = new Student();
thread.start();
for(int i = 0; i < 100; i++){
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("小刚领先了,加油! 当前线程名: " + Thread.currentThread().getName());
}
}
}
class Student extends Thread{
public void run(){
for(int i = 0; i < 100; i++){
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("小明领先了,加油! 当前线程名: " + this.getName());
}
}
}
setDaemon()
可以将指定的线程设置成后台线程,创建后台线程的线程结束时,后台线程也随之消亡,只能在线程启动之前把它设为后台线程
public static void main(String[] args){
Thread thread = new Student();
thread.setDaemon(true); //后台线程
thread.start();
for(int i = 0; i < 100; i++){
System.out.println("小刚领先了,加油! 当前线程名: " + Thread.currentThread().getName());
}
}
interrupt()
并没有直接中断线程,而是需要被中断线程自己处理
stop()
结束线程,不推荐使用。
yield
让当前正在执行线程暂停,不是阻塞线程,而是将线程转入就绪状态,如果调用了yield方法之后,没有其他等待执行的线程,这个时候当前线程就会马上恢复执行!
线程同步
线程同步的实现方案
同步代码块
synchronized(obj){}
同步方式
private synchronized void makeWithdrawal(int amt) {}
Lock锁
售票案例(Synchronized)
public class Test {
public static void main(String[] args){
Ticket ticket = new Ticket();
//创建Thread类
Thread A = new Thread(ticket,"A窗口");
Thread B = new Thread(ticket,"B窗口");
Thread C = new Thread(ticket,"C窗口");
//启动线程
A.start();
B.start();
C.start();
}
}
class Ticket implements Runnable{
private int ticket = 5;
@Override
public void run() {
for(int i = 0; i < 100; i++){ //每个窗口排了100个人
synchronized (this){
if(ticket > 0){ //有票
try {
Thread.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "正在卖第" + ticket-- + " 张票");
}
}
}
}
}
这个时候我们会看到票是一张一张的来卖的
假如没有锁呢?
那么就会出现这种情况
认识同步监视器(锁子)
synchronized(同步监视器){ }
必须是引用数据类型,不能是基本数据类型
在同步代码块中可以改变同步监视器对象的值,不能改变其引用
尽量不要String和包装类Integer做同步监视器.如果使用了,只要保证代码块中不对其进行任何操作也没有关系
一般使用共享资源做同步监视器即可
也可以创建一个专门的同步监视器,没有任何业务含义
建议使用final修饰同步监视器
同步代码块的执行过程
第一个线程来到同步代码块,发现同步监视器open状态,需要close,然后执行其中的代码
第一个线程执行过程中,发生了线程切换(阻塞 就绪),第一个线程失去了cpu,但是没有开锁open
第二个线程获取了cpu,来到了同步代码块,发现同步监视器close状态,无法执行其中的代码,第二个线程也进入阻塞状态
第一个线程再次获取CPU,接着执行后续的代码;同步代码块执行完毕,释放锁open
第二个线程也再次获取cpu,来到了同步代码块,发现同步监视器open状态,重复第一个线程的处理过程(加锁)
线程同步优点是比较安全,缺点就是效率低下,可能出现死锁。
多个代码块使用了同一个同步监视器(锁),锁住一个代码块的同时,也锁住所有使用该锁的所有代码块,其他线程无法访问其中的任何一个代码块,多个代码块使用了同一个同步监视器(锁),锁住一个代码块的同时,也锁住所有使用该锁的所有代码块, 但是没有锁住使用其他同步监视器的代码块,其他线程有机会访问其他同步监视器的代码块
Lock锁
JDK1.5中推出了新一代的线程同步方式:Lock锁
class Ticket implements Runnable{
private int ticket = 5;
private Lock lock = new ReentrantLock(); //可重入锁
@Override
public void run() {
for(int i = 0; i < 100; i++){ //每个窗口排了100个人
try{
//上锁
lock.lock();
if(ticket > 0){ //有票
try {
Thread.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "正在卖第" + ticket-- + " 张票");
}
}finally {
//解锁
lock.unlock();
}
}
}
}
Lock锁
JDK1.5后新增功能,与采用synchronized相比,lock可提供多种锁方案,更灵活
java.util.concurrent.lock 中的 Lock 框架是锁定的一个抽象,它允许把锁定的实现作为 Java 类,而不是作为语言的特性来实现。这就为 Lock 的多种实现留下了空间,各种实现可能有不同的调度算法、性能特性或者锁定语义。
ReentrantLock 类实现了 Lock ,它拥有与 synchronized 相同的并发性和内存语义, 但是添加了类似锁投票、定时锁等候和可中断锁等候的一些特性。此外,它还提供了在激烈争用情况下更佳的性能。
注意:如果同步代码有异常,要将unlock()写入finally语句块
Lock和synchronized的区别
Lock是显式锁(手动开启和关闭锁,别忘记关闭锁),synchronized是隐式锁,遇到异常自动解锁
Lock只有代码块锁,synchronized有代码块锁和方法锁
Lock锁可以对读不加锁,对写加锁,synchronized不可以
Lock锁可以有多种获取锁的方式,可以从sleep的线程中抢到锁,synchronized不可以
使用Lock锁,JVM将花费较少的时间来调度线程,性能更好。并且具有更好的扩展性(提供更多的子类)
优先使用顺序:
Lock----同步代码块(已经进入了方法体,分配了相应资源)----同步方法(在方法体之外)