在比如售票的代码中如下:
public class CellRunnable implements Runnable{
//这个票让三个线程共享
static int piao=1000; //共享数据
//确保这个锁对象,只有一个,多个线程共用一把锁
static Object obj=new Object();
@Override
public void run() {
while (true) {
// 假如就剩最后一张票 int piao=1;
synchronized (obj){
if (piao >= 1) {
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "正在出售第:" + (piao--) + " 张票");
}
}
}
}
}
public class MyTest {
public static void main(String[] args) {
CellRunnable cellRunnable = new CellRunnable();
Thread th1 = new Thread(cellRunnable, "窗口1");
Thread th2 = new Thread(cellRunnable, "窗口2");
Thread th3= new Thread(cellRunnable, "窗口3");
th1.start();
th2.start();
th3.start();
我们写的这段售票代码,出现了线程安全问题。多线程的环境下,在对共享数据进行操作时,有可能会出现线程安全问题。出现安全问题的原因在于一下因素:
1.为多线程环境?
2.多个线程在共享数据?
3.多个语句在操作某个变量?
出现以上情况,我们会发生线程安全问题,所以要解决以上 问题,需要用到线程同步。
线程同步
若多个线程操作同一个资源,可能会出现线程不安全的情况。
处理多线程问题时,多个线程访问同一个对象,并且某些线程还想修改这个对象,这时候就需要线程同步。线程同步实质上就是一种等待机制,多个需要同时访问此对象的线程进入这个对象的等待池形成队列,等待前面线程使用完毕,下一个线程再使用。
由于同一个进程的多个线程共享同一块存储空间,为了保证数据在方法中被访问时的正确性,在访问时加入锁机制synchronized,当一个线程获得对象的排它锁,独占资源,其他线程必须等待,使用后释放锁即可。
同步代码块:
synchronized (锁){放你认为有肯能出现问题的代码}
锁:你可以使用Java里面的任意一个对象,来充当锁,注意,多个线程要共享一把锁,才能锁住
public class CellRunnable implements Runnable {
//这个票让三个线程共享
static int piao = 100; //共享数据
//确保这个锁对象,只有一个,多个线程共用一把锁
static Object obj = new Object();
int i = 1;
@Override
public void run() {
while (true) {
// 假如就剩最后一张票 int piao=1;
//th1 th2 th3
if (i % 2 == 0) {
synchronized (this) { //或者synchronized (CellRunnable.class)
//当th1这个线程进来同步代码块后,就持有了这个锁,其他线程没有持有锁,那么就要处于等待状态,等在同步代码块的外面
if (piao >= 1) {
//模拟一下真实的售票环境,有网络延迟。
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "正在出售第:" + (piao--) + " 张票");
}
}
} else {
maiPiao();
}
i++;
//th1 执行完了,出了同步代码块,就会释放锁。释放锁了之后,多个线程再去争抢CPU的时间片
}
}
//同步方法:我们可以把一个方法用synchronized这个关键字修饰,来封装一段代码,来解决线程安全问题
//同步方法:默认用的锁对象是this
public synchronized void maiPiao() {
//System.out.println(this);
if (piao >= 1) {
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "正在出售第:" + (piao--) + " 张票");
}
}
}
或者
public class CellRunnable implements Runnable {
//这个票让三个线程共享
static int piao = 100; //共享数据
//确保这个锁对象,只有一个,多个线程共用一把锁
static Object obj = new Object();
@Override
public void run() {
while (true) {
// 假如就剩最后一张票 int piao=1;
//th1 th2 th3
maiPiao();
//th1 执行完了,出了同步代码块,就会释放锁。释放锁了之后,多个线程再去争抢CPU的时间片
}
}
// 同步方法的使用的是 this 这个锁对象
public synchronized void maiPiao() {
//当th1这个线程进来同步代码块后,就持有了这个锁,其他线程没有持有锁,那么就要处于等待状态,等在同步代码块的外面
if (piao >= 1) {
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "正在出售第:" + (piao--) + " 张票");
}
}
}
lock():加锁
public class CellRunnable implements Runnable {
//这个票让三个线程共享
static int piao = 100; //共享数据
static ReentrantLock lock=new ReentrantLock();
@Override
public void run() {
while (true) {
// 假如就剩最后一张票 int piao=1;
//th1 th2 th3
//加锁
lock.lock();
try {
if (piao >= 1) {
//模拟一下真实的售票环境,有网络延迟。
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "正在出售第:" + (piao--) + " 张票");
}
}catch (Exception e){
e.printStackTrace();
}finally {
//释放锁 不管有没有遇到异常,锁必须释放
lock.unlock();
}
}
}
}
该机制会带来以下问题:
一个线程持有锁会导致其他所有需要此锁的线程挂起;
在多线程竞争下,加锁,释放锁会导致比较多的上下文切换和调度延时,引起性能问题;
如果一个优先级高的线程等待一个优先级低的线程释放锁,会导致优先级倒置,引起性能问题。
线程死锁
概念:多个线程各自占有一些共享资源,并且互相等待其他线程占有的资源才能运行。而导致两个或者多个线程都在等待对方释放资源,都停止执行的情形。某一个同步块同时拥有“两个以上对象的锁”时,就可能发生“死锁”的问题
产生死锁的必要条件:
上面列出的死锁的四个必要条件,只要想办法破坏其中的任意一个或多个条件,就可以避免死锁发生
假设有两个女生,在出门之前同时进行化妆(需要拿镜子和口红),若一个女生先拿到镜子,另一个女生先拿到口红,之后,为了得到彼此的口红和镜子,两方都需要等待。解决
public class DeadLocked {
public static void main(String[] args) {
Makeup g1 = new Makeup(0,"白雪公主");
Makeup g2 = new Makeup(1,"灰姑凉");
new Thread(g1).start();
new Thread(g2).start();
}
}
//化妆
class Makeup implements Runnable{
//选择
int choice;
//谁进来了
String girlName;
//两个对象
static LipStick lipStick = new LipStick();
static Mirror mirror = new Mirror();
public Makeup(int choice,String girlName){
this.choice = choice;
this.girlName = girlName;
}
@Override
public void run() {
//化妆
try {
makeup();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//化妆的方法
public void makeup() throws InterruptedException {
if (choice==0){ //先拿口红,再拿镜子
synchronized (lipStick){
System.out.println("拿到口红");
Thread.sleep(1000);
//等待拿镜子的人释放锁
}
synchronized (mirror){
System.out.println("拿到镜子");
}
}else { //先拿镜子 , 再拿口红
synchronized (mirror){
System.out.println("拿到镜子");
Thread.sleep(2000);
//等待拿口红的人释放锁
}
synchronized (lipStick){
System.out.println("拿到口红");
}
}
}
}
//口红
class LipStick{
}
//镜子
class Mirror{
}
Lock(锁)
从JDK 5.0开始,Java提供了更强大的线程同步机制——通过显示定义同步锁对象来实现同步。同步锁使用Lock对象充当
java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问,每次只能有一个线程对Lock对象加锁,线程开始访问共享资源之前应先获得Lock对象
ReentranLock类实现了Lock,它拥有与synchronized相同的并发性和内存语义,在实现线程安全的控制中,比较常用的是ReentrantLock,可以显式加锁、释放锁
public class TestLock {
public static void main(String[] args) {
HelloWorld helloWorld = new HelloWorld();
new Thread(helloWorld).start();
new Thread(helloWorld).start();
}
}
class HelloWorld implements Runnable{
int ticketNums = 100;
//可重入锁
private final ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
while (true){
try {
lock.lock(); //加锁
//判断是否有票
if (ticketNums>0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(ticketNums--);
}else {
break;
}
} finally {
lock.unlock();//解锁
}
}
}
}
synchronized 与 Lock 的对比
Lock是显式锁(手动开启和关闭锁,别忘记关闭锁)synchronized是隐式锁,出了作用域自动释放
Lock只有代码块锁,synchronized有代码块锁和方法锁
使用Lock锁,JVM将花费较少的时间来调度线程,性能更好。并且具有更好的扩展性(提供更多的子类)
优先使用顺序:
Lock > 同步代码块(已经进入了方法体,分配了相应资源) > 同步方法(在方法体之外)
线程协作——生产者消费者模式
应用场景:生产者和消费者问题
分析:这是一个线程同步问题,生产者和消费者共享同一个资源,并且生产者和消费者之间相互依赖,互为条件
线程方法:针对线程之间互相通信的问题,Java提供了几个方法用于解决
解决方式:针对生产者/消费者模式的问题,有两种方法可以解决
管程法
生产者:负责生产数据的模块(可能是方法、对象、线程、进程);
消费者:负责处理数据的模块(可能是方法、对象、线程、进程);
缓冲区:消费者不能直接使用生产者的数据,它们之间有一个缓冲区
生产者将生产好的数据放入缓冲区,消费者从缓冲区拿出数据
示例如下:
//思路
//1.思考需要哪些对象?
// 生产 , 消费 , 产品 , 容器
//2.分工
/*
生产者只管生产
消费者只管消费
鸡: 实体类
容器 :
容器添加数据.
要判断容器是否满 , 满了等待消费者消费
没有满,通知生产者生产
容器减少数据
判断还有没有数据, 没有数据的话 . 等待生产者生产
消费完毕 , 通知生产者生产
*/
import java.sql.SQLOutput;
//测试生产者和消费者问题
public class TestPC {
public static void main(String[] args) {
SynContainer synContainer = new SynContainer();
new Productor(synContainer).start();
new Consumer(synContainer).start();
}
}
//生产者
class Productor extends Thread{
//需要向容器中加入产品
SynContainer container;
public Productor(SynContainer container){
this.container = container;
}
@Override
public void run() {
for (int i = 1; i < 100; i++) {
//生产者添加产品
container.push(new Chicken(i));
System.out.println("生产者生产了"+i+"鸡");
}
}
}
//消费者
class Consumer extends Thread{
SynContainer container;
public Consumer(SynContainer container){
this.container = container;
}
@Override
public void run() {
for (int i = 1; i < 100; i++) {
//消费者拿走产品
Chicken chicken = container.pop();
System.out.println("消费者消费了"+chicken.id+"鸡");
}
}
}
//缓冲区-->容器
class SynContainer{
//容器
Chicken[] chickens = new Chicken[10];
//容器的计数器
int num = 0;
//生产者放入产品
public synchronized void push(Chicken chicken) {
//假如容易已经满了,就不用放,等待消费者消费
if (num>=chickens.length){
//等待消费者消费
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//假如容器没有满 , 通知生产生成
System.out.println("num,,,,,"+num);
chickens[num] = chicken;
System.out.println("数组有多少个元素"+num);
num++;
//通知消费者消费
this.notifyAll();
}
//消费者拿走产品
public synchronized Chicken pop(){
//假如容器空的,等待
if (num<=0){
//等待生产
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
num--;
Chicken chicken = chickens[num];
//通知生产者生产
this.notifyAll();
return chicken;
}
}
//产品->鸡
class Chicken {
int id;
public Chicken(int id) {
this.id = id;
}
信号灯法
在产品中设置一个标志位,利用标志位(flag)来选择让生产者执行逻辑还是让消费者执行逻辑(类似于红灯停,绿灯行)
示例如下:
//生产者消费2
//生产者--->演员
//消费者--->观众
//产品:信号灯--->电视----->声音
public class TestPC2 {
public static void main(String[] args) {
TV tv = new TV();
new Player(tv).start();
new Watcher(tv).start();
}
}
//生产者
class Player extends Thread{
TV tv;
public Player(TV tv){
this.tv = tv;
}
@Override
public void run() {
for (int i = 0; i < 20; i++) {
if (i%2==0){
this.tv.play("节目:快乐大本营播放中");
System.out.println();
}else {
this.tv.play("广告:抖音,记录美好生活");
}
}
}
}
//消费者
class Watcher extends Thread{
TV tv;
public Watcher(TV tv){
this.tv = tv;
}
@Override
public void run() {
for (int i = 0; i < 20; i++) {
tv.watch();
}
}
}
//电视
class TV{
//演员说话 , 观众等待
//观众观看 , 演员等待
boolean flag = true;
//说话
String voice;
//表演
public synchronized void play(String voice){
//演员等待
if (!flag){
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("表演了"+voice);
this.voice = voice;
//让观众观看
this.notifyAll();
this.flag = !this.flag;
}
//观看
public synchronized void watch(){
//观众等待
if (flag){
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("观众听到了: "+voice);
//通知演员说话
this.notifyAll();
this.flag = !this.flag;
}
线程池
背景:经常创建和销毁、使用量特别大的资源,比如并发情况下的线程,对性能影响很大
思路:提前创建好多个线程,放入线程池中,使用时直接获取,使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具
好处:
public class ThreadPool{
public static void main(String[] args) {
//创建一个线程池(池子大小)
ExecutorService pool = Executors.newFixedThreadPool(10);
//执行runnable接口实现类
pool.execute(new MyThread4());
pool.execute(new MyThread4());
pool.execute(new MyThread4());
pool.execute(new MyThread4());
//关闭连接池
pool.shutdown();
}
}
class MyThread4 implements Runnable{
@Override
public void run() {
System.out.println("MyThread4");
}
}
Timer 定时器 一种工具,线程用其安排以后在后台线程中执行的任务。可安排任务执行一次,或者定期重复执行。
Timer timer = new Timer();
//让定时器,执行定时任务
MyTimerTask myTimerTask = new MyTimerTask(timer);
//等3秒之后执行任务
// timer.schedule(myTimerTask,3000);
//等3秒第一次执行任务,以后间隔1秒重复执行定时任务
timer.schedule(myTimerTask, 3000,1000);
//取消定时任务
// myTimerTask.cancel();
//取消定时器
//timer.cancel();
}
}
class MyTimerTask extends TimerTask{
private Timer timer;
public MyTimerTask(Timer timer) {
this.timer = timer;
}
@Override
public void run() {
System.out.println("执行");
//取消定时器
// timer.cancel();
}
}
Timer timer = new Timer();
//在指定日期执行定时任务
MyTask task = new MyTask();
String dateStr="2020-06-07 09:48:00";
//在指定日期执行定时任务
Date date = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(dateStr);
//在指定日期执行定时任务一次
// timer.schedule(task,date);
//在指定日期第一次执行任务,以后间隔1s重复执行
timer.schedule(task, date,1000);
}
}
class MyTask extends TimerTask{
@Override
public void run() {
System.out.println("定时任务执行了");
}
}
练习:定时删除一个文件夹
Timer timer = new Timer();
String dateStr = "2020-06-07 10:16:00";
//在指定日期执行定时任务
Date date = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(dateStr);
MyTask myTask = new MyTask(timer);
timer.schedule(myTask,date);
}
}
class MyTask extends TimerTask{
private Timer timer;
public MyTask(Timer timer) {
this.timer = timer;
}
@Override
public void run() {
File folder = new File("C:\\Users\\ShenMouMou\\Desktop\\demo");
deleteFolder(folder);
//关闭定时器
timer.cancel();
System.out.println("删除完毕");
}
private void deleteFolder(File folder) {
File[] files = folder.listFiles();
for (File f : files) {
if (f.isFile()) {
f.delete();
}else{
deleteFolder(f);
}
}
folder.delete();
}
}