多线程拓展

最新推荐文章于 2024-07-19 17:37:28 发布
最新推荐文章于 2024-07-19 17:37:28 发布
阅读量122 收藏
点赞数
分类专栏： JavaSE 文章标签： java 多线程 并发编程 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/changlinke/article/details/113486610
版权

多线程拓展

守护线程

守护线程又叫做兜底线程，每当程序运行，都会默认开启一个守护线程，用于监听我们正常的程序。

守护线程就是在当前线程执行完毕，守护线程就会跟着结束执行，注意完成垃圾回收等功能。

使用setDaemon()方法把某个线程设置为守护线程
但是必须在启动线程之前设置守护线程，否则会报错

如：

public class Thread_01_Daemon {
    public static void main(String[] args) {
        Thread thread1 = new Processor_01();
        thread1.setName("Thread->1->");
        //设置守护线程
        thread1.setDaemon(true);
        thread1.start();
        for (int i = 0; i < 10; i++) {
            System.out.println("main-->" + i);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class Processor_01 extends Thread {
    @Override
    public void run() {
        int i = 0;
        while (true) {
            System.out.println(Thread.currentThread().getName() + " = " + i++);
            try {
                sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

在main线程执行完毕后，thread1线程会立即结束运行。

Timer定时器

在JDK类库中Timer类主要负责计划任务的功能，也就是在指定的时间开始执行某一个任务。此类也常用来做一下周期性同步工作。

使用schedule()方法设置定时器
方法参数为：

  1. 需要执行的任务类
  2. 执行任务的起始时间
  3. 执行任务的时间间隔

如：

public class Thread_02_Timer {
    public static void main(String[] args) {
        //创建定时器
        Timer timer = new Timer();
        //执行任务对象
        LogTimerTask logTimerTask = new LogTimerTask();
        //指定起始时间
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
        //任务  起始时间   间隔时间（毫秒）
        try {
            timer.schedule(logTimerTask, sdf.parse("2021-01-30 21:24:58 150"), 1000 * 3);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        //System.out.println(sdf.format(new Date()));
    }
}

class LogTimerTask extends TimerTask {
    @Override
    public void run() {
        //格式化时间对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
        //获取当前系统时间，为毫秒数
        Date date = new Date();
        //格式化输出时间
        System.out.println(sdf.format(date));
    }
}

死锁

锁的相关知识

如果访问了一个对象中加锁的成员方法,那么该对象中所有的加锁的成员方法全部锁定,都不能被其他线程访问。和静态方法无关

如果访问了一个类加锁的静态方法,那么该类中所有的加锁的静态方法都被锁定,不能访问。和成员方法无关。

如测试代码：

public class Thread_03_Synchronized {
    public static void main(String[] args) {
        MyClass_01 myClass_01 = new MyClass_01();
        Thread thread1 = new Thread(new Processor_03(myClass_01));
        Thread thread2 = new Thread(new Processor_03(myClass_01));
        Thread thread3 = new Thread(new Processor_03(myClass_01));
        thread1.setName("t1");
        thread2.setName("t2");
        thread3.setName("t3");
        thread1.start();
        //睡一下会儿，保证thread1先执行，先进入加锁m1方法，并睡眠5秒
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thread2.start();
        thread3.start();
    }
}

class Processor_03 implements Runnable{
    MyClass_01 myClass_01;

    public Processor_03(MyClass_01 myClass_01) {
        this.myClass_01 = myClass_01;
    }

    @Override
    public void run() {
        if ("t1".equals(Thread.currentThread().getName())){
            myClass_01.m1();
        }else if ("t2".equals(Thread.currentThread().getName())){
            myClass_01.m2();
        }else if ("t3".equals(Thread.currentThread().getName())){
            myClass_01.m3();
        }
    }
}

//业务类
class MyClass_01 {
    public synchronized void m1() {
        System.out.println(Thread.currentThread().getName()+"****"+"加锁的成员方法m1，即将进入睡眠");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public synchronized void m2() {
        System.out.println(Thread.currentThread().getName()+"****"+"加锁的成员方法m2");
    }

    public void m3() {
        System.out.println(Thread.currentThread().getName()+"****"+"未加锁的成员方法m3");
    }
}

代码块锁

语法格式：
synchronized(xxx){} 代码块锁,可以锁类,也可以锁对象。

如果锁对象，括号中应填写对象名，当防卫该代码块锁的时候，该对象中所有的代码块锁和加锁的成员方法都被锁定。同理访问对象中加锁的成员方法的时候，代码快锁也会被锁定。

如果锁类，当访问该代码块的时候，该类中所有的代码块锁和加锁的静态方法都被锁定，同理，访问类中加锁的静态方法的时候，代码块锁也会被锁定。

死锁

两个线程分别占用对方需要的同步资源，等在等待对象释放资源。出现死锁后，不会出现异常，不会出现提示，所有的线程都处于阻塞状态，程序无法继续执行。

原理：

  1. 某个线程的执行完成，需要先后，嵌套，锁定执行两个对象，并且先执行对象1
  2. 另一个线程的执行完成，需要先后，嵌套，锁定执行两个对象，并且先执行对象2
  3. 在第一个线程中，要去访问对象2的时候，发现被锁定了，只能等待
  4. 在第二个线程中，要去访问对象1的时候，发现被锁定，只能等待

实现死锁的思路：

  1. 两个线程
  2. 两个对象
  3. 两个线程中保存的对象时相同的
  4. 线程1先访问对象1再嵌套访问对象2
  5. 线程2先访问对象2再嵌套访问对象1

如：

public class Thread_04_DeadLock 
    public static void main(String[] args) {
        Object o1 = new Object();
        Object o2 = new Object();
        Thread t1 = new T1(o1, o2);
        Thread t2 = new T2(o1, o2);
        t1.start();
        t2.start();
    }
}

class T1 extends Thread {
    Object o1;
    Object o2;

    public T1(Object o1, Object o2) {
        this.o1 = o1;
        this.o2 = o2;
    }

    @Override
    public void run() {
        synchronized (o1) {
            System.out.println("*************");
            //加入睡眠，保证一定会死锁，因为到这里先确保让t2把o2锁定
            try {
                sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (o2) {
                System.out.println("T1执行完成");
            }
        }
    }
}

class T2 extends Thread {
    Object o1;
    Object o2;

    public T2(Object o1, Object o2) {
        this.o1 = o1;
        this.o2 = o2;
    }

    @Override
    public void run() {
        synchronized (o2) {
            System.out.println("-------------------");
            //加入睡眠，保证一定会死锁，因为到这里先确保让t1把o1锁定
            try {
                sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (o1) {
                System.out.println("T2执行完成");
            }
        }
    }
}

线程通信

使用Object中方法实现

  1. wait():该线程进入等待状态，功能还在，只是没有运行，当被唤醒之后进入就绪状态，当执行的时候接着当前等待的状态继续执行。
    必须用在成员方法中，因为是对象相关，并且该成员方法必须加上synchronized。
    无参或者传入0，说明不会自动唤醒，只能被notifyAll()/notify唤醒。
    也可以传入long类型的值，单位是毫秒，过了指定时间之后自动醒。
  2. notify():唤醒该对象上等待中的某一个线程（优先级）
  3. notifyAll():唤醒该对象上所有等待的线程

实现生产者和消费者问题：
实现思路：

  1. 有一个业务类，SunStack 其中有一个成员变量cnt用来保存生产的个数，还需要一个容器来存储生产的数据char[]。
  2. 业务类需要有对应的生产方法和消费方法
    ① 生产push：想数组中添加元素，需要判断数组是否满了，如果满了就不生产，唤醒消费者
    ② 消费pop：同上，判断使用没有数据，如果没有就唤醒生产者
    ③ 两个线程分别调用生产和消费

如实现：

public class Thread_06_ProducerConsumer {
    public static void main(String[] args) {
        SynStack synStack = new SynStack();
        Thread thread1 = new Thread(new Consumer(synStack));
        Thread thread2 = new Thread(new Producer(synStack));
        thread1.start();
        thread2.start();
    }
}

//消费者
class Consumer implements Runnable {
    SynStack synStack;

    public Consumer(SynStack synStack) {
        this.synStack = synStack;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            synStack.pop();
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

//生产者
class Producer implements Runnable {
    SynStack synStack;

    public Producer(SynStack synStack) {
        this.synStack = synStack;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            synStack.push((char) ('a' + i));
        }
    }
}

class SynStack {
    //保存生产的个数，同时也是下一个元素的下标
    int cnt = 0;
    char[] data = new char[6];

    public synchronized void push(char c) {
        //生产个数如果和容器大小一致，说明生产满了，就不再生产
        if (cnt == data.length) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        //唤醒消费者
        notifyAll();
        //把元素保存到数组中
        data[cnt] = c;
        //容器中个数+1
        cnt++;
        System.out.println("生产了 : " + c + " , 容器中剩余 " + cnt + " 个字符");
    }

    public synchronized char pop() {
        //容器中个数为0，就不进行消费
        if (cnt == 0) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //唤醒生产者
        notifyAll();
        //cnt先进行--操作，因为cnt保存的是下一个元素的小标
        cnt--;
        char c = data[cnt];
        System.out.println("消费了 : " + c + " , 容器中剩余 " + cnt + " 个字符");
        return c;
    }
}

线程单例模式的使用

原因：
线程启动后，如果同时调用单例模式创建对象的方法，将会都在if中判断为null，多个线程会创建不同的单例模式的对象，为了避免这个问题，将getInstance()方法同步。

如果在方法声明上加入synchronized可以实现，但是一旦跳过第一次，后续不管多少个并发/并行singLethon_01都不会等于null，就不会再创建。而我们使用synchronized，效率会降低太多，除了第一次，以后使用这个方法，都需要排队等待。降低了程序的运行效率。
所以需要在方法中使用同步代码块来实现。并且在同步代码块中需要再次判断对象是否为null，否则第一次执行时，虽然都在排队，当第一个线程创建完对象，第二个线程会进入同步代码块继续创建一个对象。

如：

ublic class SingLethon_01 {
    //私有化构造方法
    private SingLethon_01() {

    }

    //创建私有化静态变量，类名为当前类类名
    private static SingLethon_01 singLethon_01 = null;

    //加锁可以实现
    //但是一旦跳过第一次，后续不管多少个并发/并行singLethon_01都不会等于null，就不会再创建
    //而我们使用synchronized，效率会降低太多，除了第一次，以后使用这个方法，都需要排队等待
    //而程序中，只需要第一次排队等待即可
    /*public synchronized static SingLethon_01 getInstance() {
        if (singLethon_01 == null) {
            singLethon_01 = new SingLethon_01();
        }

        return singLethon_01;
    }*/

    public static SingLethon_01 getInstance() {
        if (singLethon_01 == null) {
            //添加第二层判断是因为如果有线程都执行到了这一行，在排队等待
            //第一个线程进入创建完对象后
            //第二个线程进入，没有if判断会再次创建对象
            synchronized (SingLethon_01.class) {
                if (singLethon_01 == null) {
                    singLethon_01 = new SingLethon_01();
                }
            }
        }
        return singLethon_01;
    }
}

这样创建就可以保证创建出来的都是同一个对象

线程池的使用

概述

背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程， 对性能影响很大。

思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完 放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交 通工具。

使用线程池的好处：

  1. 提高响应速度（减少了创建新线程的时间）
  2. 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
  3. 便于线程管理.

JDK 5.0起提供了线程池相关API：ExecutorService 和 Executors。

  1. ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor。
  2. Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
  • Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池
  • Executors.newFixedThreadPool(n); 创建一个可重用固定线程数的线程池
  • Executors.newSingleThreadExecutor() ：创建一个只有一个线程的线程池
  • Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。

创建一个可根据需要创建新线程的线程newCachedThreadPool

创建一个可缓存的线程池，如果线程池长度超过处理需要，可以灵活回收空闲线程。
若没有可以回收的，则新建线程，线程池规模不存在限制，数量不固定

如：

public class _01_NewCachedThreadPoolTest {
    public static void main(String[] args) {
        //创建线程池
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        for (int i = 0;i<1000;i++){
            //执行任务，传入Runnable的匿名内部类，也可以是实现类对象
            cachedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName());
                }
            });
        }
        System.out.println("======================");
        cachedThreadPool.shutdown();
    }
}

创建一个固定长度线程池newFixedThreadPool

可控制线程最大并发数，超出此数量的线程，会在队列中等待。

如：

public class _02_NewFixedThreadPoolTest {
    /*
     * 创建一个固定长度线程池，可控制线程最大并发数
     * 超出此数量的线程，会在队列中等待
     *
     * */
    public static void main(String[] args) {
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);

        for (int i = 0; i < 100; i++) {
            fixedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName());
                }
            });
        }
        System.out.println("=============");
        fixedThreadPool.shutdown();
    }
}

创建定时及周期性执行任务newScheduledThreadPool

有两种实现方法：

  1. 延迟执行
  2. 延迟并间隔执行

需传入执行的任务，延迟时间，延迟时间单位
如：

public class _03_NewScheduledThreadPool {
    public static void main(String[] args) {
        // 创建池子,并指定数量5
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
        //执行
        //执行的任务，延迟时间，延迟时间的单位
        scheduledThreadPool.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("延迟3秒再执行");
            }
        }, 3, TimeUnit.SECONDS);

        //关闭池子
        scheduledThreadPool.shutdown();
    }
}

需传入执行的任务，延迟时间，时间间隔，延迟时间单位。
注意：不可以关闭池子，否则无法运行。
如：

public class _03_NewScheduledThreadPool {
    public static void main(String[] args) {
        // 创建池子,并指定数量5
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
        //执行
        //执行的任务，延迟时间，时间间隔，延迟时间的单位
        scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("延迟3秒再执行，并且每2秒执行一次");
            }
        }, 3, 2, TimeUnit.SECONDS);
        //不可以关闭池子，关闭池子该方法无法运行
        //关闭池子
        //scheduledThreadPool.shutdown();
    }
}

单线程池newSingleThreadExecutor

只创建一个线程，如果这个线程因为异常或正常结束，则会有一个新的线程来替代它。
执行顺序按照先来后到顺序执行，谁先来谁先执行。
适用于一个一个任务执行的情况

如：

public class _04_NewSingletThreadExecutor {
    public static void main(String[] args) {
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();

        //一次性创建十个请求
        for (int i = 0;i<10;i++){
            final int index = i;
            System.out.println("创建 "+i+" 次");
            //只能依次执行
            singleThreadExecutor.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(1000);
                        System.out.println(Thread.currentThread().getName()+" : "+index);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }
}
Karglo
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程杂谈
weixin_44696477的博客
07-16 148
线程与进程 进程 是指一个内存中运行的应用程序，每一个进程都有一个独立的内存空间 线程 是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行，一个进程至少有一个线程 线程是进程的进一步划分，进程启动后的若干执行路径又可划分为若干个线程 线程调度 分时调度 所有线程轮流使用CPU的使用权，平均给配每个线程占用CPU的时间 抢占式调度（Java） 优先让优先级高的线程使用（CPU），相同时随机 CPU在多个线程中高速切换，对于CPU一个核一个时刻只能执行一个线程，一位内切换速度和处理时
多线程的概述
weixin_69492399的博客
05-02 504
多线程
Java多线程（拓展）
Coding~Farmer
07-31 259
多线程 三种实现方式： Thread Runnable Callable Thread 作为子线程的类需继承Thread类，重写run()方法。 创建继承了Thread类的对象，使用start()方法启动子线程。 主线程（main()）与子线程同时运行： 结果： Main：26 Thread：3 Main：27 Thread：4 Main：28 Thread：5 Thread：6 Main：29 Thread：7 Main：30 Thread：8 Main：31 Thread：9 Thre
JAVA多线程——(一)多线程编程
wenge1477的博客
11-10 230
JAVA多线程——多线程编程 文章目录JAVA多线程——多线程编程【一】线程创建【二】线程状态转换【三】守护线程【四】线程同步【五】线程死锁【六】synchronied【七】wait和notify【八】链接 【一】线程创建 Thread创建： 如果要使用Thread来创建线程，需要新建一个类来继承Thread，重新run方法 class MyThread extends Thread { ...
JAVA多线程之扩展ThreadPoolExecutor
weixin_33991727的博客
12-25 352
ThreadPoolExecutor是可扩展的，通过查看源码可以发现，它提供了几个可以在子类化中改写的方法：beforeExecute,afterExecute,terminated. 源码片段如下所示： protected void beforeExecute(Thread t, Runnable r) { } protected void afte...
用户线程 (User Thread)、守护线程 (Daemon Thread)
09-19 242
在Java中有两类线程：用户线程(User Thread)、守护线程(Daemon Thread)。 所谓守护 线程，是指在程序运行的时候在后台提供一种通用服务的线程，比如垃圾回收线程就是一个很称职的守护者，并且这种线程并不属于程序中不可或缺的部分。因 此，当所有的非守护线程结束时，程序也就终止了，同时会杀死进程中的所有守护线程。反过来说，只要任何非守护线程还在运行，程序就不...
线程同步基础——守护线程的使用(Daemon Thread)
IUNIQUE技术册
09-11 420
线程同步基础——守护线程的使用目录Daemon Thread概念代码例子 目录 守护线程的例子分享 Daemon Thread概念 守护线程通常执行一些特殊任务,当所有用户线程终止的时候,JVM会简单的丢弃掉所有现存的守护线程.一旦其它非守护线程执行完就会丢弃，不一定所有的守护线程都会执行完才退出，它们可能在非守护线程执行完后的某个时刻就会退出. 代码例子 此例子模拟了一个子线程守护主线程的场景，...
C++11多线程编程
06-10
本课程，讲解的重点定位在c++11新标准中的多线程开发部分，同时，老师还会结合自己的经验把多线程的讲解进一步拓展到一个比较大的范畴，因为无论是c++11多线程开发还是各种其他的多线程开发实现方法，都有很多类似的...
多线程和socket例子
01-03
在IT领域，多线程和Socket编程是网络通信和并发处理的重要组成部分。在这个"多线程和socket例子"中，我们将深入探讨这两个概念以及它们如何协同工作以实现客户端与服务器端之间的通信。 首先，让我们来了解多线程。...
多线程编程初学者指南
11-29
总的来说，学习和掌握多线程编程，无论是对深入理解Win32操作系统，还是对拓展到其他平台，都有着重要的价值。它不仅可以提升软件的响应速度，还能提高系统的整体效率，为开发高效、稳定的多任务应用打下坚实基础。...
php线程pthreads扩展
04-26
在PHP编程中，Pthreads扩展提供了一种在脚本级别上使用多线程的能力，使得PHP开发者可以利用多核处理器的并行...然而，多线程编程也带来了额外的复杂性和挑战，因此在实际项目中，需谨慎评估是否适合采用这一技术。
易语言-多线程注册源码（纯源码自动识别简单验证码）
06-29
本篇将深入探讨一篇名为“多线程注册源码（纯源码自动识别简单验证码）”的技术实现，涉及的主要知识点包括多线程编程、图像处理以及验证码识别。 首先，我们要理解多线程编程的核心概念。多线程是指在一个程序中...
java学习笔记_线程
今生今世的专栏
05-03 1034
一、Java线程：概念与原理 1、操作系统中线程和进程的概念 现在的操作系统是多任务操作系统。多线程是实现多任务的一种方式。进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以启动多个线程。比如在Windows系统中，一个运行的exe就是一个进程。线程是指进程中的一个执行流程，一个进程中可以运行多个线程。比如java.exe进程中可以运行很多
Java中守护线程的总结
热门推荐
观千剑而后识器，操千曲而后晓声。
05-23 11万+
在Java中有两类线程：User Thread(用户线程)、Daemon Thread(守护线程)  用个比较通俗的比如，任何一个守护线程都是整个JVM中所有非守护线程的保姆： 只要当前JVM实例中尚存在任何一个非守护线程没有结束，守护线程就全部工作；只有当最后一个非守护线程结束时，守护线程随着JVM一同结束工作。 Daemon的作用是为其他线程的运行提供便利服务，守护线程最典型的应用就是
线程拓展（join用法）
qq_36428821的博客
01-30 160
我们一起来看一张图： 如何让出当前线程的执行权 yield()方法，只在JDK某些内部实现才能看到，是让出执行权，基本用不到。让出之后变成可运行状态。 join方法 t.join()方法只会使主线程(或者说调用t.join()的线程)进入等待池并等待t线程执行完毕后才会被唤醒。并不影响同一时刻处在运行状态的其他线程。 分析： package CSDN; public class TestJoin { public static void main(String[] args) thr
python进程-守护进程原理-，互斥锁与join区别-队列-生产者消费者模式
Marck
07-15 886
1.守护进程     守护进程其实就是一个‘子进程’     守护=》伴随         1.守护进程会伴随主进程的代码运行完毕后而死掉         2.守护进程内无法再开启子进程,否则抛出异常 2.为何用守护进程：     关键字就两个：             进程：                     当父进程需要将一个任务并发出去执行，需要将该任务放在一个子进程里...
Java-多线程拓展知识
xiao-fei的博客
08-12 106
扩展知识1：读写锁** ReadWriteLock接口：可以实现多个读线程同时读取数据，写线程需要互斥执行。 读|写 、写|写 需要互斥 读|读 不需要互斥 示例：创建资源类` public class Res { private int num; public int getNum() { return num; } public voi...
java多线程-Producer-consumer(生产者消费者模式）
专注=成功
08-26 458
多线程中生产者消费者模式是非常重要的模式，如果之前的几个模式都通晓了，这个模式也就水到渠成了。废话少说，下面开始模拟. 模拟功能需要实现如下要求： 1，厨师（MakerThread）会做蛋糕（String）放在桌子（Table）上。 2，桌子太小，顶多可以放3个蛋糕。 3，桌上已经放满3个蛋糕，而厨师还要放上蛋糕的话，会等待到桌子上出现空间为止。 4，客人（EaterThread）...
Java内存模型
最新发布
weixin_44267758的博客
07-19 315
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
Java软件开发核心知识：JVM、多线程、基础、泛型和Spring
本文将对Java的核心知识点进行总结，并详细讨论JVM、多线程、Java基础、泛型和Spring等重要概念。 首先，我们将从JVM（Java虚拟机）开始讨论。JVM是Java语言的运行环境，它允许Java程序在不同的操作系统和硬件上...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值