多线程
并发与并行(了解)
- 并行(parallel):指多个事件任务在同一时刻发生(同时发生)。指在同一时刻,有多条指令在多个处理器上同时执行。单核CPU同一时刻只能处理一条指令,所以单核CPU做不到并行处理。
- 并发(concurrency):指两个或多个事件在同一个微小的时间段内发生。指在同一个时刻只能有一条指令执行,但多个进程的指令被快速轮换执行,使得在宏观上具有多个进程同时执行的效果。程序并发执行可以在有限条件下,充分利用CPU资源,这是我们研究的重点。
单核CPU:只能并发
多核CPU:并行+并发
线程与进程
-
程序:为了完成某个任务和功能,选择一种编程语言编写的一组指令的集合。
-
软件:1个或多个应用程序+相关的素材和资源文件等构成一个软件系统。
-
进程是对一个程序运行过程(创建-运行-消亡)的描述,系统会为每个运行的程序建立一个进程,并为进程分配独立的系统资源,比如内存空间等资源。
-
线程:线程是进程中的一个执行单元,负责完成执行当前程序的任务,一个进程中至少有一个线程。一个进程中是可以有多个线程的,这时这个应用程序也可以称之为多线程程序。多线程使得程序可以并发执行,充分利用CPU资源。
面试题:进程是操作系统调度和分配资源的最小单位,线程是CPU调度的最小单位。不同的进程之间是不共享内存的。进程之间的数据交换和通信的成本是很高。不同的线程是共享同一个进程的内存的。当然不同的线程也有自己独立的内存空间。对于方法区,堆中中的同一个对象的内存,线程之间是可以共享的,但是栈的局部变量永远是独立的。
线程调度
指CPU资源如何分配给不同的线程。常见的两种线程调度方式:
-
分时调度
所有线程轮流使用 CPU 的使用权,平均分配每个线程占用 CPU 的时间。
-
抢占式调度
优先让优先级高的线程使用 CPU,如果线程的优先级相同,那么会随机选择一个(线程随机性),Java采用的是抢占式调度方式。
-
抢占式调度详解
大部分操作系统都支持多进程并发运行,现在的操作系统几乎都支持同时运行多个程序。比如:现在我们上课一边使用编辑器,一边使用录屏软件,同时还开着画图板,dos窗口等软件。此时,这些程序是在同时运行,”感觉这些软件好像在同一时刻运行着“。
实际上,CPU(中央处理器)使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核而言,某个时刻,只能执行一个线程,而 CPU的在多个线程间切换速度相对我们的感觉要快,看上去就是在同一时刻运行。
其实,多线程程序并不能提高程序的运行速度,但能够提高程序运行效率,让CPU的使用率更高。
-
线程的创建与启动
java虚拟机是支持多线程的,当运行Java程序时,至少已经有一个线程了,那就是main线程。
继承Thread类
Java中java.lang.Thread
是表示线程的类,每个Thread类或其子类的实例代表一个线程对象。
通过继承Thread类来创建并启动多线程的步骤:
- 定义Thread类的子类,并重写该类的run()方法,该run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体。
- 创建Thread子类的实例,即创建了线程对象
- 调用线程对象的start()方法来启动该线程
自定义线程类:
public class MyThread extends Thread {
//定义指定线程名称的构造方法
public MyThread(String name) {
//调用父类的String参数的构造方法,指定线程的名称
super(name);
}
/**
* 重写run方法,完成该线程执行的逻辑
*/
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(getName()+":正在执行!"+i);
}
}
}
测试类:创建线程对象并启动线程
public class Demo01 {
public static void main(String[] args) {
//创建自定义线程对象
MyThread mt = new MyThread("新的线程!");
//开启新线程
mt.start();
//在主方法中执行for循环
for (int i = 0; i < 10; i++) {
System.out.println("main线程!"+i);
}
}
}
注意事项:
-
手动调用run方法不是启动线程的方式,只是普通方法调用。
-
start方法启动线程后,run方法会由JVM调用执行。
-
不要重复启动同一个线程,否则抛出异常
IllegalThreadStateException
-
不要使用Junit单元测试多线程,不支持,主线程结束后会调用
System.exit()
直接退出JVM;
实现Runnable接口
Java有单继承的限制,当我们无法继承Thread类时,那么该如何做呢?在核心类库中提供了Runnable接口,我们可以实现Runnable接口,重写run()方法,然后再通过Thread类的对象代理启动和执行我们的线程体run()方法
通过实现Runnable接口创建线程并启动的步骤:
- 定义Runnable接口的实现类,并重写该接口的run()方法,该run()方法的方法体同样是该线程的线程执行体。
- 创建Runnable实现类的实例,并以此实例作为Thread的target来创建Thread对象,该Thread对象才是真正
的线程对象。 - 调用线程对象的start()方法来启动线程。
自定义线程任务类:
public class MyRunnable implements Runnable{
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName()+" "+i);
}
}
}
测试类:创建线程对象并启动线程
public class Demo {
public static void main(String[] args) {
//创建自定义类对象 线程任务对象
MyRunnable mr = new MyRunnable();
//创建线程对象
Thread t = new Thread(mr, "小强");
t.start();
for (int i = 0; i < 20; i++) {
System.out.println("旺财 " + i);
}
}
}
利用Callable接口、FutureTask对象实现。
可以得到线程执行的结果 通过 FutureTask对象. get()
①、得到任务对象
1.定义类实现Callable接口,重写call方法,封装要做的事情。
import java.util.concurrent.Callable;
public class CallableThread implements Callable {
@Override
public Object call() throws Exception {
int sum =0;
for (int i = 1; i <= 100; i++) {
sum+=i;
}
return sum;
}
}
2.用FutureTask把Callable对象封装成线程任务对象。
CallableThread ct = new CallableThread();
FutureTask fk = new FutureTask<>(ct);
②、把线程任务对象交给Thread处理。
③、调用Thread的start方法启动线程,执行任务
Thread thread = new Thread(futureTask);
thread.start();
④、线程执行完毕后、通过FutureTask的get方法去获取任务执行的结果。
System.out.println(futureTask.get());
//callable类
import java.util.concurrent.Callable;
public class CallableThread implements Callable {
@Override
public Object call() throws Exception {
int sum =0;
for (int i = 1; i <= 100; i++) {
sum+=i;
}
return sum;
}
}
//test
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;
public class Test {
public static void main(String[] args) throws ExecutionException, InterruptedException {
CallableThread callableThread = new CallableThread();
FutureTask futureTask = new FutureTask<>(callableThread);
Thread thread = new Thread(futureTask);
thread.start();
System.out.println(futureTask.get());
}
}
两种创建线程方式比较
-
Thread类本身也是实现了Runnable接口的,run方法都来自Runnable接口,run方法也是真正要执行的线程任务。
public class Thread implements Runnable {}
-
因为Java类是单继承的,所以继承Thread的方式有单继承的局限性,但是使用上更简单一些。
-
实现Runnable接口的方式,避免了单继承的局限性,并且可以使多个线程对象共享一个Runnable实现类(线程任务类)对象,从而方便在多线程任务执行时共享数据。
匿名内部类对象创建线程
匿名内部类对象的方式创建线程,并不是一种新的创建线程的方式,只是在线程任务只需执行一次的情况下,我们无需单独创建线程类,可以采用匿名对象的方式:
new Thread("新的线程!"){
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(getName()+":正在执行!"+i);
}
}
}.start();
new Thread(new Runnable(){
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName()+":" + i);
}
}
}).start();
构造方法
- public Thread() :分配一个新的线程对象。
- public Thread(String name) :分配一个指定名字的新的线程对象。
- public Thread(Runnable target) :分配一个带有指定目标新的线程对象。
- public Thread(Runnable target,String name) :分配一个带有指定目标新的线程对象并指定名字
线程使用基础方法
-
public void run() :此线程要执行的任务在此处定义代码。
-
public String getName() :获取当前线程名称。
-
public static Thread currentThread() :返回对当前正在执行的线程对象的引用。
-
public final int getPriority() :返回线程优先级
-
public final void setPriority(int newPriority) :改变线程的优先级
- 每个线程都有一定的优先级,优先级高的线程将获得较多的执行机会。每个线程默认的优先级都与创建它的父线程具有相同的优先级。Thread类提供了setPriority(int newPriority)和getPriority()方法类设置和获取线程的优先级,其中setPriority方法需要一个整数,并且范围在[1,10]之间,通常推荐设置Thread类的三个优先级常量:
- MAX_PRIORITY(10):最高优先级
- MIN _PRIORITY (1):最低优先级
- NORM_PRIORITY (5):普通优先级,默认情况下main线程具有普通优先级。
public static void main(String[] args) {
Thread t = new Thread(){
public void run(){
System.out.println(getName() + "的优先级:" + getPriority());
}
};
t.setPriority(Thread.MAX_PRIORITY);
t.start();
System.out.println(Thread.currentThread().getName() +"的优先级:" + Thread.currentThread().getPriority());
}
线程控制常见方法
-
public void start() :导致此线程开始执行; Java虚拟机调用此线程的run方法。
-
public static void sleep(long millis) :线程睡眠,使当前正在执行的线程以指定的毫秒数暂停(暂时停止执行)。
-
public static void yield() :礼让线程,会将本次抢到的执行权让出去重新再抢。
-
void join() :加入线程,当前线程中加入一个新线程,等待加入的线程终止后再继续执行当前线程。
void join(long millis) :等待该线程终止的时间最长为 millis 毫秒。如果millis时间到,将不再等待。
void join(long millis, int nanos) :等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒。
-
public final void stop():强迫线程停止执行。 该方法具有不安全性,已被弃用,最好不要使用。
- 调用 stop() 方法会立刻停止 run() 方法中剩余的全部工作,包括在 catch 或 finally 语句中的,并抛出ThreadDeath异常(通常情况下此异常不需要显示的捕获),因此可能会导致一些清理性的工作的得不到完成,如文件,数据库等的关闭。
- 调用 stop() 方法会立即释放该线程所持有的所有的锁,导致数据得不到同步,出现数据不一致的问题。
-
public void interrupt():中断线程,实际上是给线程打上一个中断的标记,并不会真正使线程停止执行。
-
public static boolean interrupted():检查线程的中断状态,调用此方法会清除中断状态(标记)。
-
public boolean isInterrupted():检查线程中断状态,不会清除中断状态(标记)
倒计时(sleep)
public static void main(String[] args) {
for (int i = 10; i>=0; i--) {
System.out.println(i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("新年快乐!");
}
强行加塞(join)
加入线程,当前线程中加入一个新线程,等待加入的线程终止后再继续执行当前线程。
import java.util.Scanner;
public class TestJoin {
public static void main(String[] args) {
ChatThread t = new ChatThread();
t.start();
for (int i = 1; i <= 10; i++) {
System.out.println("main:" + i);
//当main打印到5之后,需要等join进来的线程停止后才会继续了。
if(i==5){
try {
t.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
class ChatThread extends Thread{
public void run(){
Scanner input = new Scanner(System.in);
while(true){
System.out.println("是否结束?(Y、N)");
char confirm = input.next().charAt(0);
if(confirm == 'Y' || confirm == 'y'){
break;
}
}
input.close();
}
}
守护线程(线程名.setDaemon(true))
当其他非守护线程执行完毕之后,守护线程会陆续结束。
public class TestThread {
public static void main(String[] args) {
MyDaemon m = new MyDaemon();
m.setDaemon(true);
m.start();
for (int i = 1; i <= 100; i++) {
System.out.println("main:" + i);
}
}
}
class MyDaemon extends Thread {
public void run() {
while (true) {
System.out.println("我一直守护者你...");
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
线程安全
当我们使用多个线程访问同一资源(可以是同一个变量、同一个文件、同一条记录等)的时候,但是如果多个线程中对资源有读和写的操作,就会出现前后数据不一致问题,这就是线程安全问题。
线程安全问题引出
局部变量不能共享
示例代码:
package com.atguigu.safe;
public class SaleTicketDemo1 {
public static void main(String[] args) {
Window w1 = new Window();
Window w2 = new Window();
Window w3 = new Window();
w1.start();
w2.start();
w3.start();
}
}
class Window extends Thread{
public void run(){
int total = 100;
while(total>0) {
System.out.println(getName() + "卖出一张票,剩余:" + --total);
}
}
}
结果:发现卖出300张票。
问题:局部变量是每次调用方法都是独立的,那么每个线程的run()的total是独立的,不是共享数据。
不同对象的实例变量不共享
package com.atguigu.safe;
public class SaleTicketDemo2 {
public static void main(String[] args) {
TicketSaleThread t1 = new TicketSaleThread();
TicketSaleThread t2 = new TicketSaleThread();
TicketSaleThread t3 = new TicketSaleThread();
t1.start();
t2.start();
t3.start();
}
}
class TicketSaleThread extends Thread{
private int total = 10;
public void run(){
while(total>0) {
System.out.println(getName() + "卖出一张票,剩余:" + --total);
}
}
}
结果:发现卖出300张票。
问题:不同的实例对象的实例变量是独立的。
静态变量是共享的
示例代码:
package com.atguigu.safe;
public class SaleTicketDemo3 {
public static void main(String[] args) {
TicketThread t1 = new TicketThread();
TicketThread t2 = new TicketThread();
TicketThread t3 = new TicketThread();
t1.start();
t2.start();
t3.start();
}
}
class TicketThread extends Thread{
private static int total = 10;
public void run(){
while(total>0) {
try {
Thread.sleep(10);//加入这个,使得问题暴露的更明显
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(getName() + "卖出一张票,剩余:" + --total);
}
}
}
结果:发现卖出近100张票。
问题(1):但是有重复票或负数票问题。
原因:线程安全问题
问题(2):如果要考虑有两场电影,各卖100张票,这场卖完就没票了,新的线程对象也没有票卖了
原因:TicketThread类的静态变量,是所有TicketThread类的对象共享。本来成员变量就是run方法共享的数据,再用static不合适。
同一个对象的实例变量共享
示例代码:多个Thread线程使用同一个Runnable对象
package com.atguigu.safe;
public class SaleTicketDemo3 {
public static void main(String[] args) {
TicketSaleRunnable tr = new TicketSaleRunnable();
Thread t1 = new Thread(tr,"窗口一");
Thread t2 = new Thread(tr,"窗口一");
Thread t3 = new Thread(tr,"窗口一");
t1.start();
t2.start();
t3.start();
}
}
class TicketSaleRunnable implements Runnable{
private int total = 10;
public void run(){
while(total>0) {
try {
Thread.sleep(10);//加入这个,使得问题暴露的更明显
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "卖出一张票,剩余:" + --total);
}
}
}
结果:发现卖出近100张票。
问题:但是有重复票或负数票问题。
原因:线程安全问题
线程安全问题原因分析
总结:线程安全问题的出现因为具备了以下条件
- 多线程执行
- 共享数据
- 多条语句操作共享数据
线程安全问题解决方式
lock锁:
- 为了更清晰的表达如何加锁和释放锁,JDK5以后提供了一个新的锁对象Lock,更加灵活、方便。
- Lock实现提供比使用synchronized方法和语句可以获得更广泛的锁定操作。
- Lock是接口不能直接实例化,这里采用它的实现类ReentrantLock来构建Lock锁对象。
方法名称 | 说明 |
---|---|
public ReentrantLock() | 获得Lock锁的实现类对象 |
方法名称 | 说明 |
---|---|
void lock() | 获得锁 |
void unlock() | 释放锁 |
static Lock lock = new ReentrantLock();
lock.lock() //加锁
try{
//被锁的代码
}catch(Execption e){
//处理异常
}finally{
lock.unlock(); //释放锁
}
Java中常使用关键字synchronized 来实现同步机制:
同步方法:synchronized 关键字直接修饰方法,表示同一时刻只有一个线程能进入这个方法,其他线程在外面等着。
public synchronized void method(){
// 普通同步方法的锁对象是 this:
}
public static synchronized void method(){
//静态同步方法的锁对象是: 类名.class
}
普通方法的锁
public class Account {
int balance =1000;
public void withDraw(int money){
balance-=money;
}
//普通方法的锁
public synchronized void takeMoney() {
if (balance >= 800) {
try {
Thread.sleep(20);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
withDraw(800);
System.out.println(Thread.currentThread().getName() + " 取钱成功,余额是[" + balance + "]元");
} else {
System.out.println(Thread.currentThread().getName() + " 取钱失败 余额不足,余额是[" + balance + "]元");
}
}
}
//线程1
public class DiaoChanThread extends Thread{
Account account;
public DiaoChanThread(Account account) {
this.account = account;
}
@Override
public void run() {
account. takeMoney();
}
}
//线程2
public class LvBuThread extends Thread{
Account account;
public LvBuThread(Account account) {
this.account = account;
}
@Override
public void run() {
account.takeMoney();
}
}
//test
public class Test {
public static void main(String[] args) {
Account account = new Account();
LvBuThread lb = new LvBuThread(account);
DiaoChanThread dc = new DiaoChanThread(account);
lb.setName("吕布");
dc.setName("貂蝉");
lb.start();
dc.start();
}
}
静态方法的锁
public class Account {
static int balance =1000;
public static void withDraw(int money){
balance-=money;
}
//Account.class
public static synchronized void takeMoney(){
//1.校验余额
if(balance>=800){
try {
Thread.sleep(20);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
//2.取钱
withDraw(800);
System.out.println(Thread.currentThread().getName()+" 取钱成功,余额是["+balance+"]元");
}else{
//3.余额不足提示
System.out.println(Thread.currentThread().getName()+" 取钱失败 余额不足,余额是["+balance+"]元");
}
}
}
//线程1
public class DiaoChanThread extends Thread{
@Override
public void run() {
Account.takeMoney();
}
}
//
public class LvBuThread extends Thread{
@Override
public void run() {
Account.takeMoney();
}
}
//test
public class Test {
public static void main(String[] args) {
LvBuThread lb = new LvBuThread();
DiaoChanThread dc = new DiaoChanThread();
lb.setName("吕布");
dc.setName("貂蝉");
lb.start();
dc.start();
}
}
同步代码块:synchronized 关键字可以用于某个区块前面,表示只对这个区块的资源实行互斥访问。
格式:
synchronized(锁对象/同步监视器对象){
需要同步操作的代码
}
//注意:
//1.只有锁对象相同才会有互斥效果 一个线程进入同步代码块 其他线程无法进入
//售票线程任务类
class SaleTicket implements Runnable {
private int count = 100;
//售票线程任务
@Override
public void run() {
while (true) {
synchronized (this) {
sell();//调用售票方法
}
}
}
//提取出售票方法
private void sell() {
if (count > 0) {
System.out.println(Thread.currentThread().getName() + "--" + count);
count--;
}
}
}
//测试类
public class DemoSaleTicket {
public static void main(String[] args) {
//创建线程任务对象 使用实现Runnable接口可以直接使用非静态方法同步 因为只会创建一个对象
SaleTicket st = new SaleTicket(ticket);
//创建售票线程对象,并启动线程
new Thread(st).start();
new Thread(st).start();
}
}
- 锁的范围太小:不能解决安全问题,要同步所有操作共享资源的语句。
- 锁的范围太大:因为一旦某个线程抢到锁,其他线程就只能等待,所以范围太大,效率会降低,不能合理利用CPU资源。
单例设计模式的线程安全问题
设计模式:设计模式(Design Pattern)是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。
是软件工程中解决特定问题的最佳实践方案。它们提供了一种在软件开发中遇到常见问题时,可复用的、经过验证的解决方案
饿汉式没有线程安全问题
饿汉式:上来就创建对象
package com.atguigu.thread4;
public class OnlyOneDemo {
public static void main(String[] args) {
OnlyOne o1 = OnlyOne.INSTANCE;
OnlyOne o2 = OnlyOne.INSTANCE;
System.out.println(o1);
System.out.println(o2);
System.out.println(o1==o2);
}
}
class OnlyOne{
public static final OnlyOne INSTANCE = new OnlyOne();
//私有化构造器
private OnlyOne(){
}
}
懒汉式线程安全问题
public class Singleton {
private static Singleton ourInstance;
public static Singleton getInstance() {
//一旦创建了对象,之后再次获取对象,都不会再进入同步代码块,提升效率
if (ourInstance == null) {
//同步锁,锁住判断语句与创建对象并赋值的语句
synchronized (Singleton.class) {
if (ourInstance == null) {
ourInstance = new Singleton();
}
}
}
return ourInstance;
}
//私有化构造器
private Singleton() {
}
}
线程间通信
为什么要处理线程间通信:
多个线程在处理同一个资源,但是处理的动作(线程的任务)却不相同。而多个线程并发执行时, 在默认情况下CPU是随机切换线程的,当我们需要多个线程来共同完成一件任务,并且我们希望他们有规律的执行, 那么多线程之间需要一些通信机制,可以协调它们的工作,以此来帮我们达到多线程共同操作一份数据。
比如:线程A用来生成包子的,线程B用来吃包子的,包子可以理解为同一资源,线程A与线程B处理的动作,一个是生产,一个是消费,此时B线程必须等到A线程完成后才能执行,那么线程A与线程B之间就需要线程通信
等待唤醒机制
这是多个线程间的一种协作机制。谈到线程我们经常想到的是线程间的竞争(race),比如去争夺锁,但这并不是故事的全部,线程间也会有协作机制。
就是在一个线程满足某个条件时,就进入等待状态(wait()/wait(time)), 等待其他线程执行完他们的指定代码过后再将其唤醒(notify());或可以指定wait的时间,等时间到了自动唤醒;在有多个线程进行等待时,如果需要,可以使用 notifyAll()来唤醒所有的等待线程。wait/notify 就是线程间的一种协作机制。
- wait:线程不再活动,不再参与调度,进入 wait set 中,因此不会浪费 CPU 资源,也不会去竞争锁了,这时的线程状态即是 WAITING或TIMED_WAITING。它还要等着别的线程执行一个特别的动作,也即是“通知(notify)”或者等待时间到,在这个对象上等待的线程从wait set 中释放出来,重新进入到调度队列(ready queue)中
- notify:则选取所通知对象的 wait set 中的一个线程释放;
- notifyAll:则释放所通知对象的 wait set 上的全部线程。
注意:
被通知线程被唤醒后也不一定能立即恢复执行,因为它当初中断的地方是在同步块内,而此刻它已经不持有锁,所以她需要再次尝试去获取锁(很可能面临其它线程的竞争),成功后才能在当初调用 wait 方法之后的地方恢复执行。
总结如下:
- 如果能获取锁,线程就从 WAITING 状态变成 RUNNABLE(可运行) 状态;
- 否则,线程就从 WAITING 状态又变成 BLOCKED(等待锁) 状态
调用wait和notify方法需要注意的细节
- wait方法与notify方法必须要由同一个锁对象调用。因为:对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程。
- wait方法与notify方法是属于Object类的方法的。因为:锁对象可以是任意对象,而任意对象的所属类都是继承了Object类的。
- wait方法与notify和notifyAll方法必须要在同步代码块或者是同步函数中使用。因为:必须要通过锁对象调用这3个方法。
线程通信四步骤:
//循环
//同步代码块
//判断,共享数据是否到了末尾(已经到末尾)
//判断,共享数据是否到了末尾(没有到末尾)
public class Ticket extends Thread {
public static int count = 100;
public Ticket(String name) {
super(name);
}
@Override
public void run() {
//循环
while (count > 0) {
//同步代码块 封装了
sell();
}
}
public static synchronized void sell() {
//判断,共享数据是否到了末尾(已经到末尾)
//判断,共享数据是否到了末尾(没有到末尾)
if(count>0) System.out.println(Thread.currentThread().getName() + "卖了一张票,还剩" + --count + "张");
}
}
public class Test {
public static void main(String[] args) {
/**两个线程卖1000张票*/
Ticket ticket1 = new Ticket("窗口1");
Ticket ticket2 = new Ticket("窗口2");
ticket1.start();
ticket2.start();
}
}
生产者与消费者问题
等待唤醒机制可以解决经典的“生产者与消费者”的问题。
生产者与消费者问题(英语:Producer-consumer problem),也称有限缓冲问题(英语:Bounded-buffer problem),是一个多线程同步问题的经典案例。该问题描述了两个(多个)共享固定大小缓冲区的线程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。生产者的主要作用是生成一定量的数据放到缓冲区中,然后重复此过程。与此同时,消费者也在缓冲区消耗这些数据。该问题的关键就是要保证生产者不会在缓冲区满时加入数据,消费者也不会在缓冲区中空时消耗数据。
生产者与消费者问题中其实隐含了两个问题:
- 线程安全问题:因为生产者与消费者共享数据缓冲区,不过这个问题可以使用同步解决。
- 线程的协调工作问题:
- 要解决该问题,就必须让生产者线程在缓冲区满时等待(wait),暂停进入阻塞状态,等到下次消费者消耗了缓冲区中的数据的时候,通知(notify)正在等待的线程恢复到就绪状态,重新开始往缓冲区添加数据。同样,也可以让消费者线程在缓冲区空时进入等待(wait),暂停进入阻塞状态,等到生产者往缓冲区添加数据之后,再通知(notify)正在等待的线程恢复到就绪状态。通过这样的通信机制来解决此类问题。
一个厨师一个服务员问题
案例:有家餐馆的取餐口比较小,只能放10份快餐,厨师做完快餐放在取餐口的工作台上,服务员从这个工作台取出快餐给顾客。现在有1个厨师和1个服务员。
public class TestCommunicate {
public static void main(String[] args) {
// 1、创建资源类对象
Workbench workbench = new Workbench();
// 2、创建和启动厨师线程
new Thread("厨师") {
public void run() {
while (true) {
workbench.put();
}
}
}.start();
// 3、创建和启动服务员线程
new Thread("服务员") {
public void run() {
while (true) {
workbench.take();
}
}
}.start();
}
}
// 1、定义资源类
class Workbench {
private static final int MAX_VALUE = 10;
private int num;
//做餐
public synchronized void put() {
if (num >= MAX_VALUE) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
num++;
System.out.println(Thread.currentThread().getName() + "制作了一份快餐,现在工作台上有:" + num + "份快餐");
this.notify();
}
//取餐
public synchronized void take() {
if (num <= 0) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
num--;
System.out.println(Thread.currentThread().getName() + "取走了一份快餐,现在工作台上有:" + num + "份快餐");
this.notify();
}
}
多个厨师多个服务员问题
案例:有家餐馆的取餐口比较小,只能放10份快餐,厨师做完快餐放在取餐口的工作台上,服务员从这个工作台取出快餐给顾客。现在有多个厨师和多个服务员。
public class TestCommunicate2 {
public static void main(String[] args) {
// 1、创建资源类对象
WindowBoard windowBoard = new WindowBoard();
// 2、创建和启动厨师线程
// 3、创建和启动服务员线程
Cook c1 = new Cook("张三",windowBoard);
Cook c2 = new Cook("李四",windowBoard);
Waiter w1 = new Waiter("小红",windowBoard);
Waiter w2 = new Waiter("小绿",windowBoard);
c1.start();
c2.start();
w1.start();
w2.start();
}
}
//1、定义资源类
class WindowBoard {
private static final int MAX_VALUE = 10;
private int num;
//做餐
public synchronized void put() {
while (num >= MAX_VALUE) {//必须循环判断。
try {
this.wait();//wait后会释放锁,Cooker1线程释放后,Cooker2线程获得锁(本应Waiter获得)进来后if继续wait,释放锁,Cooker1又快速获得锁,继续向下执行。。。
} catch (InterruptedException e) {
e.printStackTrace();
}
}
num++;
System.out.println(Thread.currentThread().getName() + "制作了一份快餐,现在工作台上有:" + num + "份快餐");
this.notifyAll();
}
//取餐
public synchronized void take() {
while (num <= 0) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
num--;
System.out.println(Thread.currentThread().getName() + "取走了一份快餐,现在工作台上有:" + num + "份快餐");
this.notifyAll();
}
}
//2、定义厨师类
class Cook extends Thread{
private WindowBoard windowBoard;
public Cook(String name,WindowBoard windowBoard) {
super(name);
this.windowBoard = windowBoard;
}
public void run(){
while(true) {
windowBoard.put();
}
}
}
//3、定义服务员类
class Waiter extends Thread{
private WindowBoard windowBoard;
public Waiter(String name,WindowBoard windowBoard) {
super(name);
this.windowBoard = windowBoard;
}
public void run(){
while(true) {
windowBoard.take();
}
}
}
练习
一个数字线程打印数字: 1 2 3 4 5.....52
一个字母线程打印字母: A B C D E F.... Z
两个线程进行协作
最终效果:
1 2 A 3 4 B 5 6 C 7 8 D 9 10 E.... 51 52 Z
-----------------------------------
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15....
思路:
每一个值占用一个位置如果是3的倍数打印字母否则打印数字
//静态同步方法实现
public class Test {
public static void main(String[] args) {
NumThread numThread = new NumThread();
CharThread charThread = new CharThread();
numThread.start();
charThread.start();
}
}
public class Print {
//记录位置
static int position = 1;
//打印数字的方法
public static synchronized void printNum(int num) throws InterruptedException {
//如果是3的倍数 数字线程等待
while (position % 3 == 0) {
Print.class.wait();
}
Thread.sleep(20);
//展示数字
System.out.print(num + " ");
//更改位置
position++;
//通知字母线程打印字母
Print.class.notifyAll();
}
//打印字母的方法
public static synchronized void printChar(char c) throws InterruptedException {
//如果不是3的倍数 字母线程等待
while (position % 3 != 0) {
Print.class.wait();
}
//打印字母
System.out.print(c + " ");
//更改位置
position++;
//通知数字线程执行
Print.class.notifyAll();
}
}
public class NumThread extends Thread{
@Override
public void run() {
for (int i = 1; i <=52 ; i++) {
try {
Print.printNum(i);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
class CharThread extends Thread{
@Override
public void run() {
for(char c='A';c<='Z';c++){
try {
Print.printChar(c);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
线程生命周期
传统线程模型的五种线程状态(简单)
传统线程模型中把线程的生命周期描述为五种状态:新建(New)、就绪(Runnable)、运行(Running)、阻塞(Blocked)、死亡(Dead)。CPU需要在多条线程之间切换,于是线程状态会多次在运行、阻塞、就绪之间切换。
1. 新建
当一个Thread类或其子类的对象被声明并创建时,新生的线程对象处于新建状。此时它和其他Java对象一样,仅仅由JVM为其分配了内存,并初始化了实例变量的值。此时的线程对象并没有任何线程的动态特征,程序也不会执行它的线程体run()。
2. 就绪
但是当线程对象调用了start()方法之后,线程就从新建状态转为就绪状态。这时线程并未执行,只是具备了运行的条件,还需要获取CPU资源后才能执行。
3. 运行
如果处于就绪状态的线程获得了CPU资源,开始执行run()方法的线程体代码,则该线程处于运行状态。如果计算机只有一个CPU,在任何时刻只有一个线程处于运行状态,如果计算机有多个处理器,将会有多个线程并行(Parallel)执行。
当然,美好的时光总是短暂的,而且CPU讲究雨露均沾。对于抢占式策略的系统而言,系统会给每个可执行的线程一个小时间段来处理任务,当该时间用完,系统会剥夺该线程所占用的资源,让其回到就绪状态等待下一次被调度。此时其他线程将获得执行机会,而在选择下一个线程时,系统会适当考虑线程的优先级。
4. 阻塞
当在运行过程中的线程遇到某些特殊情况时,线程会临时放弃CPU资源,不再执行,即进入阻塞状态。比如:线程调用了sleep()方法,会主动放弃所占用的CPU资源。
5. 死亡
线程完成任务结束或意外终止后,线程就处于死亡状态。
JDK定义的六种线程状态(了解)
在java.lang.Thread
类内部定义了一个枚举类用来描述线程的六种状态:
public enum State {
NEW,
RUNNABLE,
BLOCKED,
WAITING,
TIMED_WAITING,
TERMINATED;
}
跟传统线程模型中的线程状态不同的是:
-
枚举类中没有区分
就绪
和运行
状态,而是定义成了一种状态Runnable
。- 因为对于Java对象来说,只能标记为可运行,至于什么时候运行,不是JVM来控制的了,是OS来进行调度的,而且时间非常短暂,因此对于Java对象的状态来说,无法区分。只能我们人为的进行想象和理解。
-
传统模型中的阻塞状态在枚举类的定义中又细分为了三种状态的:
BLOCKED
、WAITING
、TIMED_WAITING
。-
BLOCKED
:是指互有竞争关系的几个线程,其中一个线程占有锁对象时,其他线程只能等待锁。只有获得锁对象的线程才能有执行机会。 -
TIMED_WAITING
:当前线程执行过程中遇到Thread类的sleep或join,Object类的wait,LockSupport类的park方法,并且在调用这些方法时,设置了时间,那么当前线程会进入TIMED_WAITING,直到时间到,或被中断。 -
WAITING
:当前线程执行过程中遇到遇到Object类的wait,Thread类的join,LockSupport类的park方法,并且在调用这些方法时,没有指定时间,那么当前线程会进入WAITING状态,直到被唤醒。-
通过Object类的wait进入
WAITING
状态的要有Object的notify/notifyAll唤醒; -
通过Condition的await进入
WAITING
状态的要有Conditon的signal方法唤醒; -
通过LockSupport类的park方法进入
WAITING
状态的要有LockSupport类的unpark方法唤醒 -
通过Thread类的join进入
WAITING
状态,只有调用join方法的线程对象结束才能让当前线程恢复;
-
说明:当从
WAITING
或TIMED_WAITING
恢复到Runnable
状态时,如果发现当前线程没有得到监视器锁,那么会立刻转入BLOCKED
状态。 -
释放锁的操作
-
当前线程的同步方法、同步代码块执行结束。
-
当前线程在同步代码块、同步方法中出现了未处理的Error或Exception,导致当前线程异常结束。
-
当前线程在同步代码块、同步方法中执行了锁对象的wait()方法,当前线程被挂起,并释放锁。
死锁
不同的线程分别锁住对方需要的同步监视器对象不释放,都在等待对方先放弃时就形成了线程的死锁。一旦出现死锁,整个程序既不会发生异常,也不会给出任何提示,只是所有线程处于阻塞状态,无法继续。
public class TestDeadLock {
public static void main(String[] args) {
Object g = new Object();
Object m = new Object();
Owner s = new Owner(g,m);
Customer c = new Customer(g,m);
new Thread(s).start();
new Thread(c).start();
}
}
class Owner implements Runnable{
private Object goods;
private Object money;
public Owner(Object goods, Object money) {
super();
this.goods = goods;
this.money = money;
}
@Override
public void run() {
synchronized (goods) {
System.out.println("先给钱");
synchronized (money) {
System.out.println("发货");
}
}
}
}
class Customer implements Runnable{
private Object goods;
private Object money;
public Customer(Object goods, Object money) {
super();
this.goods = goods;
this.money = money;
}
@Override
public void run() {
synchronized (money) {
System.out.println("先发货");
synchronized (goods) {
System.out.println("再给钱");
}
}
}
}
面试题:sleep()和wait()方法的区别
(1)sleep()不释放锁,wait()释放锁
(2)sleep()指定休眠的时间,wait()可以指定时间----也可以无限等待直到notify或notifyAll
(3)sleep()在Thread类中声明的静态方法,wait方法在Object类中声明
调用wait()方法是由锁对象调用,而锁对象的类型是任意类型的对象。
wait需要写到synchronized(锁对象中)不然会报运行时错误。
标签:Thread,void,class,线程,new,多线程,public From: https://www.cnblogs.com/21CHS/p/18528870