【Java学习】- 多线程（三）

最新推荐文章于 2022-10-09 10:20:21 发布
最新推荐文章于 2022-10-09 10:20:21 发布
阅读量170 收藏
点赞数
分类专栏： 笔记 # Java 文章标签： 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45528435/article/details/115918806
版权
笔记 同时被 2 个专栏收录
16 篇文章 0 订阅
订阅专栏
Java
14 篇文章 0 订阅
订阅专栏

N12 多线程（三）

作者：迷恋

一、线程同步

并发：同一个对象被多个线程同时操作

处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象。这时候我们就需要线程同步，线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用。

由于同一进程的多个线程共享一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加入锁机制synchronized，当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可。存在下列问题：

  • 一个线程持有锁会导致其他所有需要此锁的线程挂起；
  • 在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延迟，引起性能问题；
  • 如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级导致，引起性能问题。


    没有做线程同步的错误实例：
package demo38;

//不安全的买票
public class UnSafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();

        new Thread(buyTicket,"苦逼的我").start();
        new Thread(buyTicket,"牛逼的大佬").start();
        new Thread(buyTicket,"可恶的黄牛党").start();
    }

}

class BuyTicket implements Runnable{

   //票
   int ticketNumbers = 10;
   boolean flag = true;//外部停止标识

    @Override
    public void run() {
        //买票
        while(flag){
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private void buy() throws InterruptedException {
        //判断是否有票
        if (ticketNumbers<=0){
            flag = false;
            System.out.println("没票了");
            return;
        }
        //模拟延时
        Thread.sleep(100);

        //买票
        System.out.println(Thread.currentThread().getName()+"拿到票"+ticketNumbers--);
    }
}

运行结果：
在这里插入图片描述

发现有-1（或者其他异常结果），线程不安全

  • 1、同步方法

  • 由于我们可以通过private关键字来保证数据对象只能被方法访问，所以我们只需要针对方法提出一套机制，这套机制就是synchronized关键字，它包括两种用法：synchronized方法和synchronized块。
    同步方法：
public synchronized void method(int args[]){
	...
}
  • synchronized方法控制对”对象“的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的锁才能执行，否则线程会堵塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被堵塞的线程才能获得这个锁，继续执行。
    缺陷：若将一个大的方法声明为synchronized将会影响效率

改进上面不安全多线程抢票的实例：
在买票的方法上添加synchronized关键字
在这里插入图片描述

package demo38;

//不安全的买票
public class UnSafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();

        new Thread(buyTicket,"苦逼的我").start();
        new Thread(buyTicket,"牛逼的大佬").start();
        new Thread(buyTicket,"可恶的黄牛党").start();
    }

}

class BuyTicket implements Runnable{

   //票
   int ticketNumbers = 10;
   boolean flag = true;//外部停止标识

    @Override
    public void run() {
        //买票
        while(flag){
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private synchronized void buy() throws InterruptedException {
        //判断是否有票
        if (ticketNumbers<=0){
            flag = false;
            System.out.println("没票了");
            return;
        }
        //模拟延时
        Thread.sleep(100);

        //买票
        System.out.println(Thread.currentThread().getName()+"拿到票"+ticketNumbers--);
    }
}

运行结果：
在这里插入图片描述
问题就轻松解决了。

tips:全部都是苦逼的我抢到，只有10张票，该线程运行较快，CPU自动调度，一次性抢完了，其他的线程都还没有进来抢的机会。（让每次抢票的线程休眠100毫秒，其他线程被调度的可能变大）可把线程休眠的位置调整至如下：
在这里插入图片描述
再次运行，结果如下：
在这里插入图片描述
Nice！完美

  • 2、同步块

  • 同步块：synchronized(Obj){}
  • Obj称之为同步监视器
    • Obj可以是任何对象，但是推荐使用共享资源作为同步监视器
    • 同步方法中无需指定同步监视器，同为同步方法的同步监视器就是this，就是这个对象本身，或者是class
  • 同步监视器的执行过程：
    1、第一个线程访问，锁定同步监视器，执行其中代码。
    2、第二个线程访问，发现同步监视器被锁定，无法访问。
    3、第一个线程访问完毕，解锁同步监视器。
    4、第二个线程访问，发现同步监视器没有锁，然后锁定并访问。

还是上面买票的实例，可使用同步块： 
package demo38;

//不安全的买票
public class UnSafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();

        new Thread(buyTicket,"苦逼的我").start();
        new Thread(buyTicket,"牛逼的大佬").start();
        new Thread(buyTicket,"可恶的黄牛党").start();
    }

}

class BuyTicket implements Runnable{

   //票
   int ticketNumbers = 10;
   boolean flag = true;//外部停止标识

    @Override
    public void run() {
        //买票
        while(flag){
            try {
                buy();
                //模拟延时
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private void buy() throws InterruptedException {
        //判断是否有票
        if (ticketNumbers<=0){
            flag = false;
            System.out.println("没票了");
            return;
        }

        synchronized (this){
            //买票
            System.out.println(Thread.currentThread().getName()+"拿到票"+ticketNumbers--);
        }
    }
}

运行结果：
在这里插入图片描述

补充案例

1.1、不安全的集合：

package demo38;

import java.util.ArrayList;

public class UnSafeList {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        for (int i = 0; i < 1000; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(list.size());

    }

}

运行结果：
在这里插入图片描述
1.2、安全的集合CopyOnWriteArrayList

package demo38;


import java.util.concurrent.CopyOnWriteArrayList;

public class SafeList {
    public static void main(String[] args) {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();
        for (int i = 0; i < 1000; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(list.size());

    }

}

运行结果：
在这里插入图片描述

二、死锁

多线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而且导致两个或者多个线程都在等待对方释放资源，都停止执行的情形。某一个同步块同时拥有“两个以上对象的锁”时，就可能会发生“死锁”的问题。

实例：

package demo39;

//死锁：多个线程互相抱着对方需要的资源，形成僵持
public class DeadLock {
    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 Lipstick{

}

//镜子
class Mirror{

}

class Makeup implements Runnable{
    //需要的资源只有一份，用static来保证只有一份
    static Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();

    int choice;//选择
    String girlName;//使用化妆品的人

    Makeup(int choice,String girlName){
        this.choice = choice;
        this.girlName = girlName;
    }

    @Override
    public void run() {
        //化妆
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    //化妆，互相持有对方的锁，就是需要拿到对方的资源
    private void makeup() throws InterruptedException {
        if (choice==0){
            synchronized (lipstick){//获得口红的锁
                System.out.println(this.girlName+"获得口红的锁");
                Thread.sleep(1000);
                synchronized (mirror){//一秒后获得镜子
                    System.out.println(this.girlName+"获得镜子的锁");
                }
            }
        }else{
            synchronized (mirror){//获得镜子的锁
                System.out.println(this.girlName+"获得镜子的锁");
                Thread.sleep(2000);
                synchronized (lipstick){//一秒后想获得口红
                    System.out.println(this.girlName+"获得口红的锁");
                }
            }
        }
    }
}

运行结果：
在这里插入图片描述
程序运行到此时便卡死僵持住了，两个线程同时互相需要对方的锁，形成了死锁。

  • 产生死锁的四个必要条件：

1、互斥条件：一个资源每次只能被一个进程使用。

2、请求与保持条件：一个进程因请求资源而堵塞时，对已获得的资源保持不放。

3、不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺。

4、循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。

三、Lock锁

  • 从JDK 5.0开始，Java提供了更强大的线程同步机制–通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。
  • java.util.concurrent.locks.lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
  • ReentrantLock（可重入锁）类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常见的是ReentrantLock，可以显式加锁、释放锁。

基本写法：

class A{
	private final ReentrantLock lock = new ReentrantLock();
	public void m(){
		lock.lock();
		try{
			//保证线程安全的代码
		}finally{
			lock.unlock();
			//如果同步代码有异常，要将unlock()写入finally语句块
		}
	}
}

实例：

package demo39;

import java.util.concurrent.locks.ReentrantLock;

public class TestLock {
    public static void main(String[] args) {
        TestLock2 testLock2 = new TestLock2();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
    }
}

class TestLock2 implements Runnable{

	//票
    int ticketNumbers = 10;

    //定义lock锁
    private final ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true){
            try {
                //加锁
                lock.lock();
                if (ticketNumbers > 0) {
                    System.out.println(ticketNumbers--);
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    break;
                }
            }finally {
                //解锁
                lock.unlock();
            }
        }
    }
}

运行结果：
在这里插入图片描述

synchronized与Lock的对比

  • Lock是显式锁（手动开启和关闭锁，别忘记关锁）synchronized是隐式锁，出了作用域自动释放
  • Lock只有代码块锁，synchronized有代码块锁和方法锁
  • 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好，并且具有更好的扩展性（提供更多的子类）
  • 优先使用顺序：
    • Lock>同步代码块（已经进入了方法体，分配了相应资源）>同步方法（在方法体之外）

四、线程协作-生产者消费者模式

  • 线程通信

应用场景：生产者和消费者问题

  • 假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中产品取走消费。

  • 如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止。

  • 如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费并等待，直到仓库中再次放入产品为止。

  • 线程通信-分析

这是一个线程同步问题，生产者和消费者共享一个资源，并且生产者和消费者之间相互依赖，互为条件。

  • 对于生产者，没有生产产品之前，要通知消费者等待，而生产了产品之后，又要马上通知消费者消费。
  • 对于消费者，在消费之后，要通知生产者已经结束消费，需要生产新的产品以供消费。
  • 在生产者消费问题中，仅有synchronized是不够的
    • synchronized可阻止并发更新一个共享资源，实现了同步。
    • synchronized不能用来实现不同线程之间的消息传递（通信）。

  • Java提供了几个方法解决线程之间的通信问题
方法名作用
wait()表示线程一直等待，直到其他线程通知，与sleep不同，此方法会释放锁
wait(long timeout)指定等待的毫秒数
notify()唤醒一个处于等待状态的线程
notifyAll()唤醒一个对象上所有调用wait()方法的线程，优先级别高的线程优先调度

注意：均是Object类的方法，都只能在同步方法或者同步代码块中使用，否者会抛出异常lllegalMonitorStateException

  • 解决方法1

并发协作模型“生产者/消费者模式” -->管程法

  • 生产者：负责生产数据的模块（可能是方法，对象，线程，进程）
  • 消费者：负责处理数据的模块（可能是方法，对象，线程，进程）
  • 缓冲区：消费者不能直接使用生产者的数据，他们之间有个“缓冲区”
    生产者将生产好得到数据放入缓冲区，消费者从缓冲区拿出数据
    在这里插入图片描述
    解决代码：
package demo40;

//测试：生产者消费者模型-->利用缓冲区解决：管程法

//生产者，消费者，产品，缓冲区
public class TestPC {
    public static void main(String[] args) {
        SynContainer container = new SynContainer();

        new Producer(container).start();
        new Consumer(container).start();
    }
}

//生产者
class Producer extends Thread{
    SynContainer container;

    public Producer(SynContainer container){
        this.container = container;
    }

    //生产方法

    @Override
    public void run() {
        for (int i = 0; i < 30; i++) {
            container.push(new Chicken(i));
        }
    }
}

//消费者
class Consumer extends Thread{
    SynContainer container;
    public Consumer(SynContainer container){
        this.container = container;
    }

    @Override
    public void run() {
        for (int i = 0; i < 30; i++) {
/*            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }*/
            container.pop();
        }

    }
}

//产品
class Chicken{
    int id;//产品编号

    public Chicken(int id) {
        this.id = id;
    }
}

//缓冲区
class SynContainer{
    //需要一个容器大小
    Chicken[] chickens = new Chicken[10];
    //容器计数器
    int count = 0;

    //生产者放入产品
    public synchronized void push(Chicken chicken){
        //如果容器满了，就需要等待着消费
        while (count==10){

            //通知消费者消费，生产等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        //如果没有满，我们就需要丢入产品
        chickens[count] = chicken;
        count++;
        System.out.println("生产了一只id为"+chicken.id+"的鸡，生产区存有"+count+"只鸡");


        //可以通知消费者消费了
        this.notifyAll();

    }

    //消费者消费产品
    public synchronized Chicken pop(){
        //判断能否消费，没有鸡就等待
        while (count==0){
            //等待生产者生产，消费者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        //如果有鸡可以消费
        Chicken chicken = chickens[count-1];
        System.out.println("消费了--》id为"+chicken.id+"只鸡");
        chickens[count-1]=null;
        count--;

        //吃完了，通知生产者生产
        this.notifyAll();
        return chicken;
    }

}

运行结果：
在这里插入图片描述

  • 解决方法2

并发协作模式“生产者/消费者模式”–>信号灯法

解决代码：

package demo41;

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("美腿、丝袜");
            }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{
    //制作人制作视频，刷抖音的等待    T
    //刷抖音的刷视频，制作人等待      F
    String voice; //抖音视频
    boolean flag = true;

    //制作视频
    public synchronized void play(String voice){

        if (!flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println("视频制作人制作了抖音视频"+voice);

        //通知刷抖音的来刷
        this.notifyAll();//通知唤醒
        this.voice = voice;
        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;
    }

}

运行结果：
在这里插入图片描述

五、线程池

  • 使用线程池

  • 背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。
  • 思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用，类似生活中的公共交通工具。
  • 好处：
    • 提高响应速度（减少了创建新线程的时间）
    • 降低了资源消耗（重复利用线程池中线程，不需要每次都创建）
    • 便于线程管理（…）
      • corePoolSize：核心池的大小
      • maximumPoolSize：最大线程数
      • keepAliveTime：线程没有任务时最多保持多长时间后会终止
  • JDK 5.0起提供了线程池相关API：EXecutorService和Executors
  • ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
    • void execute(Runnable command)：执行任务/命令，没有返回值，一般来执行Runnable
    • < T >Future< T > submit(Callable< T > task)：执行任务，有返回值，一般又来执行Callable
    • void shutdown()：关闭连接池
  • Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池

实例：

package demo42;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ForkJoinPool;

//测试线程池
public class TestPool {

    public static void main(String[] args) {
        //1、创建服务，创建线程池
        //newFixedThreadPool 参数为线程池大小
        ExecutorService service = Executors.newFixedThreadPool(10);

        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());

        //2、关闭连接
        service.shutdown();
    }
}


class MyThread implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

运行结果：
在这里插入图片描述

༄迷恋࿐
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
生产者消费者Java多线程实现
永无止境，上下求索
12-31 2730
生产者和消费者问题是最经典的模拟多线程合作的问题之一，本文将提供一个具有多个生产者和多个消费者的Java实现。主要涉及到资源的锁定，多线程的合作，以及任务的抽象。 产品的抽象 每个产品都有一个唯一编号no，在构造函数里面初始化。 static class Product { private static int index = 0; private int no; public
java 多线程写缓存_Java多线程学习笔记之二缓存
weixin_39747293的博客
02-16 442
1、高速缓存由来：处理器处理能力原因大于主内存(DRAM)访问速率，为了弥补这个差距，引入了高速缓存。高速缓存是一种存取速率远比主内存大而容量远比主内存小的存储部件，每一个处理器都有其高速缓存。在引入高速缓存之后，处理器执行读、写操作时就不直接操作主内存，而是通过高速缓存执行的。变量名相当于内存地址，变量值相当于相应内存空间中存储的数据。可以理解为，高速缓存为程序中的数据做了一份对应主内存的副本，...
java多线程：生产消费模式（缓冲区Chennel）
weixin_37549458的博客
07-15 558
缓冲区 package com.example.ConsumerAndProducer; public class ChannelCake { private final String[] buffer; private int putPos;// 放置的位置 private int takePos;// 拿走的位置 private int count;// 缓冲区放置实时个数 public ChannelCake(int maxCount){ t
java基础之多线程详细掌握
yushenshili的博客
06-12 294
线程的简介 线程实现的三种方式 线程状态，线程同步 线程通信问题 高级主题 线程的简介 例如边吃饭边玩手机 生活中有太多这样同时做多件事情的例子，看起来是多个任务都在做，其本质上我们的大脑在同一时间依旧只做了一件事情 多个线程组成一个进程，QQ，应用，播放器，等 1、进程（process） 一个启动的应用程序就是进程，执行程序的过程，启动后就分配了内存 和 CPU 2、线程（thread） 进程中的一段顺序执行流，它是cpu执行和调度的最基本的单元 只是程序计数器用一点点内存，其他资源共享进程资源 3、.
Java基础知识点汇总 六 Buffer缓冲区
学以致用 知行合一
10-09 1333
从Buffer类的Java文档中可以发现，Buffer类是一个抽象类，它具有7个直接子类，分别是ByteBuffer、CharBuffer、DoubleBuffer、FloatBuffer、IntBuffer、LongBuffer、ShortBuffer，也就是缓冲区中存储的数据类型并不像普通I/O流只能存储byte或char数据类型，Buffer类能存储的数据类型是多样的。1、适合使用String类的场景：在字符串不经常变化的场景中可以使用String类，例如常量的声明、少量的变量运算。
JAVA-多线程 所有文件
01-09
这个“JAVA-多线程 所有文件”压缩包很可能包含了一系列关于Java多线程学习的源代码示例和相关文档。下面我们将深入探讨Java多线程的相关知识点。 1. **线程的概念**：线程是操作系统分配CPU时间的基本单位，一个...
Java-学习多线程总结上
12-22
所以在进程之上的进一步划分就变得非常的重要，而且性能也会有所提高，所有的线程一定要依附进程才能够存在，那么进程一旦消失，线程也一定会消失，但反过来不一定，而Java是支持多线程的开发语言之一。 2. 多线程的...
java课件-5-多线程
最新发布
01-10
"java课件-5-多线程"的主题显然聚焦于这个核心概念，旨在教授如何在Java环境中有效地利用多线程来提升程序的执行效率。 Java中的多线程允许程序同时执行多个独立的任务，这在处理I/O密集型或计算密集型任务时非常...
java学习资料-线程
06-16
对于复杂的多线程场景，可以利用Java并发包提供的高级工具，如CountDownLatch、CyclicBarrier、Semaphore等来简化同步和协调。总之，理解并熟练掌握Java中的线程技术，对于编写高效、稳定的并发程序至关重要。
java-多线程学习代码.zip
10-19
多线程的学习的笔记 Thread1:继承Thread类 * Thread2:继承Runnable接口 * * ThreadMethod：一些Thread常见方法 * ThreadTestDome1 练习：创建两个线程 其中一个线程遍历100以内的偶数 另一个遍历一百内奇数 ...
java多线程实现生产者和消费者
12-22
java多线程实现生产者和消费者 ，4种实现方式，分别为synchronizated，condition和lock，信号量，阻塞队列
死锁的产生
mxdxm8899的专栏
10-14 162
产生死锁的四个必要条件：（1） 互斥条件：一个资源每次只能被一个进程使用。（2） 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。（3） 不剥夺条件:进程已获得的资源，在末使用完之前，不能强行剥夺。（4） 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。这四个条件是死锁的必要条件，只要系统发生死锁，这些条件必然成立，而只要上述条件之一不满足，就不会发生死锁。...
IllegalMonitorStateException异常原因及解决办法
热门推荐
周涛的博客
08-04 4万+
在同步控制方法或同步控制块里调用wait()，notify()和notifyAll()。如果在非同步控制方法里调用这些方法，程序能通过编译，但运行的时候，将得到IllegalMonitorStateException异常，并伴随着一些含糊的消息，比如"当前线程不是拥有者"。消息的意思是，调用wait()，notify()和notifyAll()的线程在调用这些方法前必须"拥有"对象的锁。当前的线程
IllegalMonitorStateException异常
程序缘
05-26 520
如果调用wait（）方法的线程没有事先获取该对象的监视器锁，则调用wait（）方法时调用线程会抛出IllegalMonitorStateException异常。 例如(错误示范) public static void main(String arg[]) throws InterruptedException{ Object obj = new Object(); obj.wait(); } 异常信息： Exception in thread "main" jav..
Java每日5问（第34天）
qq_39899164的博客
07-17 107
产生死锁的条件? 1、互斥条件：一个资源每次只能被一个进程使用。 2、请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。 3、不剥夺条件:进程已获得的资源，在末使用完之前，不能强行剥夺。 4、循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。 请写出实现线程安全的几种方式? 方式一：使用同步代码块方式二：使用同步方法 方式三：使用ReentrantLock 守护线程是什么？它和非守护线程的区别? 程序运行完毕,jvm 会等待非守护线程完成后关闭,但是 jvm 不会等待守护线程.
金三银四前夕，一定要熬夜看完今年最新java后端面试题-【上篇】
Java烂猪皮
01-30 900
1、在 java 中守护线程和本地线程区别？ java 中的线程分为两种：守护线程（Daemon）和用户线程（User）。 任何线程都可以设置为守护线程和用户线程，通过方法 Thread.setDaemon(bool on)；true 则把该线程设置为守护线程，反之则为用户线程。Thread.setDaemon() 必须在 Thread.start()之前调用，否则运行时会抛出异常。 两者的区别： 唯一的区别是判断虚拟机(JVM)何时离开，Daemon 是为其他线程提供服务，如果 全部的 Us
java多线程实现生产者与消费者
Aierbude的博客
07-27 515
只是自己的理解有错误还请指出： 工厂类： public class MyFactory { private int foodNum = 0; public int getFoodNum() { return foodNum; } public void setFoodNum(int foodNum) { this.foodN
死锁的四个必要条件
qq_46343559的博客
06-30 680
1、互斥条件 一个资源每次只能被一个进程使用，此时若有其他进程请求该资源，则请求进程只能等待。 2、请求与保持条件 进程已经保持了至少一个资源，但又提出了新的资源请求，而该资源已被其他进程占有，此时请求进程被阻塞，但对自己已获得的资源保持不放。 3、不可剥夺条件 进程所获得的资源在未使用完毕之前，不能被其他进程强行夺走，只能是主动释放。 4、循环等待条件 若干进程间形成首尾相接循环等待资源的关系 ...
JAVA语言深入--多线程
02-12
在深入学习多线程编程之前，首先要了解什么是线程和进程。在计算机中，进程是指正在执行的程序，而线程是进程中的一个执行上下文。一个进程可以包含一个或多个线程，线程可以独立执行不同的任务。当一个Java程序启动...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值