juc并发编程（二）

最新推荐文章于 2024-08-02 18:17:22 发布
最新推荐文章于 2024-08-02 18:17:22 发布
阅读量190 收藏
点赞数
文章标签： jvm java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44017091/article/details/127030606
版权

栈与栈帧
在jvm之中是由堆、栈、方法区所组成，其中每一个线程启动，就会分配一块内存

  • 每个栈是由多个栈帧组成，对应着每次调用的方法所占用的内存
  • 每一个线程只有一个活动的线帧，对应着正在执行的那个方法
package juc;

public class TestFrame {
    public static void main(String[] args) {
        method1(10);
    }
    public static void method1(int x){
        int y=x+1;
        Object m=method2();
        System.out.println(m);
    }
    public  static Object method2(){
        Object n=new Object();
        return  n;
    }

}

在method1(10)哪里打开debug模式

在这里插入图片描述
执行了两步在这里插入图片描述
在这里插入图片描述在这里插入图片描述最后一块内存被释放掉了，再依次释放在这里插入图片描述
多个线程调用内存

package juc;

public class TestFrame {
    public static void main(String[] args) {
        Thread t1=new Thread(){
            @Override
            public void  run(){
                method1(20);
            }
        };
        t1.setName("t1");
        t1.start();
        method1(10);
    }
    public static void method1(int x){
        int y=x+1;
        Object m=method2();
        System.out.println(m);
    }
    public  static Object method2(){
        Object n=new Object();
        return  n;
    }

}

改为在这里插入图片描述模式，分别在两个method1()出进行debug，就可以看见两个线程的运行

线程的上下文切换
因为一些原因导致cpu不再执行当前的线程，转而执行另一个线程的代码
1.线程的cpu时间片用完
2.垃圾回收
3.有更高的优先级的线程需要运行
4.线程自己调用了 sleep、yield、wait、join、park、synchronized、lock等方法
（1）当发生上下文发生时，需要保存操作系统的当前线程的状态，并恢复另一个线程状态,java之中对应的概念就是程序计数器，它的作用是记住下一条jvm的指令执行地址，是线程私有的
（2）状态包括程序计数器，虚拟机每个栈帧的信息，如局部变量，操作数栈，返回地址等。
（3）线程上下文切换（Context Switch）频繁发生会影响性能
###线程数不是越高越好，当线程过多的时候会频繁切换，会影响性能

线程的方法
start()

package juc;

import lombok.extern.slf4j.Slf4j;
import sun.security.pkcs11.wrapper.Constants;

import java.io.FileReader;

@Slf4j(topic = "juc.test4")
public class Test4 {
    public static void main(String[] args) {

        Thread t1=new Thread("t1"){
            @Override
            public void run(){
                log.debug("running....");
            }
        };
        System.out.println(t1.getState());
        t1.start();
        System.out.println(t1.getState());
    }
}

NEW
RUNNABLE

start()不能被多次调用

sleep()
1.调用sleep()会让当前的线程从running状态进入Timed waiting状态
2.其他线程可以使用interrupt方法打断正在睡眠的线程，这时sleep 方法会抛出InterrupteException
3.睡眠结束后的线程未必立刻得到执行
4.建议用TimeUnit的sleep代替thead的sleep来获得更好的可读性

package juc;

import lombok.extern.slf4j.Slf4j;
import sun.security.pkcs11.wrapper.Constants;

import java.io.FileReader;

@Slf4j(topic = "juc.test4")
public class Test4 {
    public static void main(String[] args) {

        Thread t1=new Thread("t1"){
            @Override
            public void run(){
                try {
                    Thread.sleep(2000);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        };

        t1.start();
        log.debug("t1 state:{}",t1.getState());
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.debug("t1.state:{}",t1.getState());


    }
}

19:25:44.886 [main] DEBUG juc.test4 - t1 state:RUNNABLE
19:25:45.421 [main] DEBUG juc.test4 - t1.state:TIMED_WAITING

Thread.interrupt();  //线程中断

Timeunit可以指定睡眠单位
部分源码

public enum TimeUnit {
    /**
     * Time unit representing one thousandth of a microsecond
     */
    NANOSECONDS {
        public long toNanos(long d)   { return d; }
        public long toMicros(long d)  { return d/(C1/C0); }
        public long toMillis(long d)  { return d/(C2/C0); }
        public long toSeconds(long d) { return d/(C3/C0); }
        public long toMinutes(long d) { return d/(C4/C0); }
        public long toHours(long d)   { return d/(C5/C0); }
        public long toDays(long d)    { return d/(C6/C0); }
        public long convert(long d, TimeUnit u) { return u.toNanos(d); }
        int excessNanos(long d, long m) { return (int)(d - (m*C2)); }
    },

例如：TimeUnit.SECONDS.sleep(1000);

yield()
1.调用yield会让当前线程从running进入runable就绪状态，然后调度其他线程
2.具体的实现依赖于操作系统任务调度器
任务调度器可能再次分配此线程
线程优先级
源码：

public final static int MIN_PRIORITY = 1;
   /**
     * The default priority that is assigned to a thread.
     */
    public final static int NORM_PRIORITY = 5;
    /**
     * The maximum priority that a thread can have.
     */
    public final static int MAX_PRIORITY = 10;

线程的优先级最低为MIN_PRIORITY 最高MAX_PRIORITY 默认NORM_PRIORITY
分配到优先级提示调度器调度该线程，但它仅仅只是一个提示，调度器可以忽略它
如果cpu比较忙，那么优先级高的线程会获得更多的时间片，但是cpu闲的时候，优先级几乎没有作用。（任务调度器决定）yeild如果让给其他线程，任务调度器可能会再次分给你任务，

package juc;

import lombok.extern.slf4j.Slf4j;

@Slf4j(topic = "juc.test6")
public class test6 {
    public static void main(String[] args) {
        Runnable task1=()->{
          int count=0;
          for(;;){
              System.out.println("-------->1-----"+count++);
          }
        };
        Runnable task2=()->{
            int count=0;
            for(;;){
//                Thread.yield();
                System.out.println("-------->2---"+count++);
            }
        };
        Thread t1=new Thread(task1,"t1");
        Thread t2=new Thread(task2,"t2");

        t1.setPriority(Thread.MIN_PRIORITY);
        t2.setPriority(Thread.MAX_PRIORITY);
        t1.start();
        t2.start();
        /**
         * 不添加任何条件 数据很接近，线程调用的次数差不多
         * 线程2加入yield() 绝大多数线程1在运行，线程2运行的时间很少
         *设置优先级，注释yield() 大部分时间都是优先级高的t2再跑
         */
    }
}

我用朋友的电脑，跑两个死循环就跑不动了，垃圾电脑**********
防止cpu 100%

while (true){
            try {
                Thread.sleep(50);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }

在没有利用cpu的计算的时候，不要让while(true)浪费 cpu的时间，使用sleep或者yield方法来把使用权给与其他程序 ，sleep 适用于无锁环境，wait和条件变量也可以有同样的效果，不过都需要需要加锁

package juc;

import lombok.extern.slf4j.Slf4j;

@Slf4j(topic = "juc.test7")
public class test7 {
    static int r=0;
    public static void main(String[] args) throws InterruptedException {
        method1();
    }

    private static void method1() throws InterruptedException {
        log.debug("开始");
        Thread t1=new Thread(()->{
            log.debug("开始");
            try {
                Thread.sleep(1);
                log.debug("结束");
                r=10;

            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        },"t1");
        t1.start();
        log.debug("结果为{}",r);
        log.debug("结束");
        Thread.sleep(10);
        log.debug("结果为{}",r);
    }
}

运行结果

00:21:13.978 [main] DEBUG juc.test7 - 开始
00:21:14.447 [main] DEBUG juc.test7 - 结果为0
00:21:14.451 [main] DEBUG juc.test7 - 结束
00:21:14.581 [main] DEBUG juc.test7 - 结果为0
00:21:14.622 [t1] DEBUG juc.test7 - 开始
00:21:14.739 [t1] DEBUG juc.test7 - 结束

当把主线程sleep改为1000时

00:25:06.085 [main] DEBUG juc.test7 - 开始
00:25:06.332 [main] DEBUG juc.test7 - 结果为0
00:25:06.339 [main] DEBUG juc.test7 - 结束
00:25:06.416 [t1] DEBUG juc.test7 - 开始
00:25:06.419 [t1] DEBUG juc.test7 - 结束
00:25:07.387 [main] DEBUG juc.test7 - 结果为10

分析
因为主线程和线程t1并行执行的，t1需要在1s之后才能计算出r=10
而主线程只能打印出r=0;
jion()
把其他线程加入当前线程，等加入线程之后完成之后，才执行当前线程。（这尼玛不就是老好人）
改一些代码：

  t1.start();
        t1.join();
        log.debug("结果为{}",r);
        log.debug("结束");
//        Thread.sleep(1000);
        log.debug("结果为{}",r);

结果

00:30:50.921 [main] DEBUG juc.test7 - 开始
00:30:51.059 [t1] DEBUG juc.test7 - 开始
00:30:51.077 [t1] DEBUG juc.test7 - 结束
00:30:51.077 [main] DEBUG juc.test7 - 结果为10
00:30:51.081 [main] DEBUG juc.test7 - 结束
00:30:51.081 [main] DEBUG juc.test7 - 结果为10

mian线程开始结束之后，t1线程才开始运行。
jion(long n)


@Slf4j(topic = "juc.test8")
public class test8 {
    static  int r1=0;
    static  int r2=0;
    public static void main(String[] args) throws InterruptedException {
        test3();
    }
    public static void test3() throws InterruptedException {
        Thread t1=new Thread(()->{
            try {
                Thread.sleep(2000);
                r1=10;
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        long start=System.currentTimeMillis();
        log.debug("jion begin");
        t1.join(1500);
        long end=System.currentTimeMillis();
        log.debug("r1:{} r2:{} cost:{}",r1,r2,end-start);
    }
}

13:47:46.612 [main] DEBUG juc.test8 - jion begin
13:47:46.616 [main] DEBUG juc.test8 - r1:0 r2:0 cost:7
codetimev
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
juc并发编程脑图以及相关示例代码
07-30
juc并发编程脑图以及相关示例代码
JUC并发编程.rar
12-14
"JUC并发编程.rar"这个压缩包文件包含了关于并发编程的相关案例源码和详细讲解，旨在帮助初学者和经验丰富的开发者深入理解并发编程的核心概念和技术。 首先，让我们来看看并发编程的基本概念。并发是指在一段时间...
JUC并发编程
热门推荐
识时务者的个人博客
07-08 14万+
JUC并发编程 JUC简介 进程、线程的关系 Java默认有两个线程 线程的六种状态 并发、并行的关系： Lock锁 Synchronized 和 Lock的区别 8锁现象 问题一 : 在标准情况下，两个线程先打印 发短信 还是 打电话 ？ 问题二 : 在发短信方法中，延迟4秒，两个线程先打印 发短信 还是 打电话？ 问题三 : Phone类增加一个普通方法，线程B调用，那么两个线程先打印 发短信
JUC(并发编程)
abc98526的博客
04-17 1万+
1.什么是JUC? JUC是指javaUtil包中的三个操作线程的包! 2.线程进程和程序 程序(Program):是一个静态的概念，一般对应于操作系统中的一个可执行的文件 ，比如：我们要启动酷狗听音乐，则对应酷狗可执行程序。当我们双击酷狗，则加载 程序到内存中，开始执行该程序，于是产生了"进程". 进程:执行中的程序叫做进程(Process),是一个动态的概念。现代的操作系统都可以同时启动多个进程。比如:我们在用酷狗听音乐，也可以使用wps写文档，也可以同时用浏览器查看网页。可以通过
JUC 并发编程
m0_53067943的博客
07-10 1032
主要对于juc的知识点总结
周阳老师JUC并发编程
qq_44300280的博客
11-16 5500
周阳老师JUC并发编程
JUC并发编程超详细详解篇
白大锅的博客，毕设WangLoveBai_999
12-15 7万+
文章目录前言一、JUC并发编程简介及准备1.1.本系列讲解思路1.2.知识储备1.3.用到的依赖1.4.logback.xml 配置二、进程与线程2.1.进程与线程2.1.1.进程2.1.2.线程2.1.3.对比2.2.并行与并发2.2.1.两者区别直观解释2.3.应用2.3.1. 应用之异步调用（案例1）2.3.2.应用之提高效率（案例1）三、Java 线程3.1.本节主讲内容3.2.创建和运行线程3.2.1.方法一，直接使用 Thread3.2.2.方法二，使用 Runnable 配合 Thread3.
JUC并发编程面试题
weixin_45081813的博客
04-06 2536
文章目录1. 并行和并发有什么区别？2. 线程和进程的基本概念、线程的基本状态以及状态之间的关系？3.守护线程是什么？4.创建线程有哪几种方式？5. sleep() 和 wait() 有什么区别？6.线程的 run() 和 start() 有什么区别？7.创建线程池有哪几种方式？8.在 Java 程序中怎么保证多线程的运行安全？9.什么是死锁？怎么防止死锁？10.synchronized 和 volatile 的区别是什么？11.synchronized 和 Lock 有什么区别？12.synchroniz
JUC 并发编程学习笔记（总）
Java技术一点通
10-19 2308
JUC指的就是工具包的简称，里面的工具类可以很方便的实现多线程的开发。java.util工具包、包、分类。业务：普通的线程代码 Thread。Runnable没有返回值、效率相比Callable相对较低！
JUC并发编程详解
yyhgo_的博客
12-13 482
JUC并发编程详解
并发编程——JUC知识脑图
庄小焱
05-16 1013
摘要 并发编程在软件编程中尤为突出和重要，在当今面试或工作中也是不可缺少的。作为一名高级java开发工程师，并发编程的技能已经成为了重要的一项。本博文将详细介绍并发编程中的知识点和知识脑图，帮助大家更好的学习和使用的并发编程。 一、并发编程知识脑图 二、并发编程知识详细解析 2.1 JUC并发编程知识脑图 并发编程——知识脑图_庄小焱的博客-CSDN博客 2.2 JUC并发大厂面试问题 并发编程——JUC并发大厂面试问题_庄小焱的博客-CSDN博客_并发编程常见问题 2.3 JU
JUC并发编程常见面试题目
corlor_龙的博客
04-26 1781
1. 进程和线程，并发和并行 进程：进程是计算机程序在一个数据集上的一次运行过程，也是资源分配和调度的基本单位 线程：线城是进程中的一个执行单元。一个进程中至少有一个线程 并行：指的是两个或多个事件在同一时刻发生， 并发：指的是两个或多个事件在同一时间间隔内发生 2. 守护线程和用户线程的区别 用户 (User) 线程：运行在前台，执行具体的任务，如程序的主线程 守护 (Daemon) 线程：运行在后台，为用户线程服务。一旦所有用户线程都结束运行，守护线程会随 JVM 一起结束工作，如垃圾回收线
Java后端开发，JUC并发编程Java后端开发，JUC并发编程
04-14
Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程...
尚硅谷大厂必备技术之JUC并发编程基础视频 配套资料（自己根据视频整理课件，和代码）
09-23
【尚硅谷】大厂必备技术之JUC并发编程视频 配套资料，自己根据视频整理 pdf 课件，和代码 视频地址：...
JUC并发编程视频教程
11-28
纠正其它同类视频的错误* 100+ 张手绘图 & 流程图，帮助你形成正确的"多线程世界观"* 以知识点为主线、穿插讲解"应用"，"原理"和"多线程设计模式"，多维度学懂并发主讲内容第一章：概览第二章：进程与线程第三章：...
内存泄漏详解
努力分享一些干货内容，纯干货，没有一点水
07-23 1678
内存泄漏是指不使用的对象持续占有内存使得内存得不到释放，从而造成内存空间的浪费。严格来说，只有对象不会再被程序用到了，但是GC又不能回收他们的情况，才叫内存泄漏。但实际情况很多时候一些不太好的实践会导致对象的生命周期变得很长，甚至导致00M，也可以叫做宽泛意义上的“内存泄漏”。举个例子，创建的连接不再使用时，需要调用close方法关闭连接，只有连接被关闭后，GC才会回收对应的对象。忘记关闭这些资源会导致持续占有内存，无法被GC回收。这样就会导致内存泄露，最终导致内存溢出。try{
JVM—CMS收集器
摸鱼小小虫的博客
08-02 152
CMS基于标记-清除算法，会产生大量的内存碎片，内存碎片过多会导致大对象的分配出现问题，严重的话会出现OOM。（Floating Garbage）：由于GC线程和用户线程并发，在GC线程运行过程中产生的垃圾就叫浮动垃圾。CMS收集器（Concurrent Mark Sweep）是一种以获取最短回收停顿时间为目标的收集器。重新标记则是为了修正并发标记期间，用户程序继续运作，导致标记变动的那一部分对象的标记记录。清理标记阶段判断已经死亡的对象，由于不需要移动存活对象，所以该过程也是与用户线程并发的。
JVM知识体系梳理
最新发布
罗曼蒂克在消亡
08-02 159
关于面试中问到的关于JVM的问题，总结
JVM相关流程的总结
罗曼蒂克在消亡
08-02 352
涉及JVM的一些流程记录和思考，不断完善中…
juc并发编程线程池
06-18
Java并发工具包（Java Util Concurrency, JUC）提供了一个强大的线程池实现，即`java.util.concurrent.Executors`和`java.util.concurrent.ThreadPoolExecutor`。线程池是并发编程中常用的一种机制，它允许您预先创建一组线程，并在需要执行任务时重用这些线程，从而提高性能和资源管理。 `Executors`类提供了一些预定义的线程池工厂方法，如`newFixedThreadPool()`, `newCachedThreadPool()`, `newScheduledThreadPool()`等，这些线程池有不同的特点： 1. `FixedThreadPool`：固定大小的线程池，一旦线程池达到最大线程数，新任务会被排队等待，直到有线程空闲出来。 2. `CachedThreadPool`：可缓存线程的线程池，线程数量根据需要动态调整，任务提交后立即执行，适合执行大量短期任务。 3. `ScheduledThreadPool`：定时线程池，可以安排任务在未来执行，支持定期和延期执行。 4. `SingleThreadExecutor`：单线程线程池，所有任务按照提交的顺序依次执行。 使用线程池时，你可以创建一个线程池实例，然后提交`Runnable`或`Callable`任务到线程池，线程池会负责管理和调度这些任务。此外，线程池还提供了便利的方法，如`submit()`, `execute()`, `call()`等，简化了任务提交和处理结果的过程。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值