多线程与高并发（一）

最新推荐文章于 2024-07-23 21:45:09 发布
最新推荐文章于 2024-07-23 21:45:09 发布
阅读量236 收藏
点赞数
分类专栏： Java多线程 文章标签： java jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fuyuanduan/article/details/128128616
版权

【前言】：

多线程、JVM、操作系统。

【概述】：

基础概念
JUC同步工具
同步容器
Disruptor //一个MQ框架，公认的单机环境下效率最高。
线程池

【线程的概念】：

【纤程】：在这里插入图片描述

【 run和start的区别 】：

        //new T1().run();    //方法调用。
        new T1().start();    //Thread类里面有start方法。

run方法还是依次顺序执行；（ 先run后main , 相当于只有一条执行路径 ）
但start方法是分支执行。（ 有分支路径 ）

【 线程的启动方式 】：

package Ten_Class.t01;

import java.util.concurrent.*;

public class T02_HowToCreateThread {
    static class MyThread extends Thread {
        @Override
        public void run() {
            System.out.println("Hello MyThread!");
        }
    }

    static class MyRun implements Runnable {
        @Override
        public void run() {
            System.out.println("Hello MyRun!");
        }
    }

    static class MyCall implements Callable<String> {
        @Override
        public String call() {
            System.out.println("Hello MyCall");
            return "success";
        }
    }

    //启动线程的5种方式
    public static void main(String[] args) throws Exception {
        new MyThread().start();
        new Thread(new MyRun()).start();
        new Thread(() -> {
            System.out.println("Hello Lambda!");
        }).start();

        FutureTask<String> task = new FutureTask<>(new MyCall());
        Thread t = new Thread(task);
        t.start();
        System.out.println(task.get());

        ExecutorService service = Executors.newCachedThreadPool();
        service.execute(() -> {
            System.out.println("Hello ThreadPool");
        });

        Future<String> f = service.submit(new MyCall());
        String s = f.get();
        System.out.println(s);
        service.shutdown();

    }
}

【 线程的方法 】：

【 sleep 】：

睡眠 ，当前线程暂停一段时间， 让给别的线程去运行。

【 yield 】：

我从CPU上先离开 ， 进入到一个等待队列里。当然有可能刚进去就被拽出去执行 ， 但更大的可能是——将等待队列中其他的拽出去执行。
我让出一下CPU ， 然后从等待队列里拽出一个来执行。

【 Join 】：

在这里插入图片描述
两个线程 t1 、 t2 ， 如果在t1线程的某个点上调用 t2.join , 这个点的意思是——立即跑到t2去运行，t1先等着，什么时候t2运行完了，t1再运行 。
在这里插入图片描述
//Join常用来用于等待另一个线程的结束。

【如何保证三个线程按照顺序执行完呢？】：

main{
	t1.join();
	t2.join();
	t3.join();
}

或者

t1{
	t2.join();
}

t2{
	t3.join();
}

【 线程的状态 】：

【NEW】：

在这里插入图片描述
//当我们新建了一个线程，new了一个，还没有调用start( ) 方法之前的线程的状态。

【 Runnable 】：

//当你调用start方法之后 ， 它会被线程调度器来执行，也就是交给操作系统来执行了。交给操作系统来执行的话，整个的状态叫做——Runnable。Runnable内部又有两个状态（ Ready就绪状态 和 Running运行状态 ） ， Ready就绪状态是指我们扔到CPU的等待队列里去了。真正的扔到CPU上去运行了——这个状态叫做Running。
Teminated状态后，不能再回到NEW状态再调用start（）了，这样是不行的。
在这里插入图片描述
【什么时候进入阻塞？】：
加synchronized进入同步代码块，我这段代码写了synchronized ， 但是我还没有得到那把锁 。
在这里插入图片描述
【 哪些是操作系统管理的？哪些是JVM管理的？ 】：
全是JVM管理的 ，因为JVM管理这些状态的时候也要通过操作系统。JVM 和 操作系统 它俩分不开 ， JVM是跑在操作系统上的程序。

【锁的概念】：

package Ten_Class.t01;

public class T_114_01 {
    private int count = 10;
    private Object o = new Object();
    
    public void m(){
        synchronized ( o ){
            count--;
            System.out.println( Thread.currentThread().getName() + " count = " +count );
        }
    }
}

【 锁的特性 】:

如果我们每一次都定义一个锁的对象（ Object o ）的话，这样的加锁方式太麻烦，每次都得New一个新的对象出来。
//所以有一个最简单的方式：

        synchronized (this){  //锁定当前方法。
			。。。。。。
        }

【Class文件】：
每一个class文件load到内存之后，它会专门生成一个class类的对象——和load到内存的那一段代码相对应；

【 方法上加sync 】：

package Ten_Class.t01;

public class T_115_02 {
    private static int count = 10;

    public synchronized static void m(){   //这里等同于synchronized (T_115_02.class)
        count--;
        System.out.println( Thread.currentThread().getName() + " count = " + count );
    }
}

【 设计小程序验证锁的问题 】：

【规则】：
加了synchronized就没有必要再加volatile了，因为synchronized既保证了原子性又保证了可见性。

【同步方法和非同步方法是否可以同时调用？】：
//下面程序段中m1是同步方法，m2是非同步方法。

/**
 * 对比前一个小程序，分析一下这个程序的输出
 */
 
package Ten_Class.t01;

public class T_116_02 {

    private int count = 10;

    public synchronized void m1() {
        System.out.println( Thread.currentThread().getName() + " m1 start...... " );
        try{
            Thread.sleep(10000 );
        }catch( InterruptedException e ){
            e.printStackTrace();
        }
        System.out.println( Thread.currentThread().getName() + " m1 end 。。。。。" );
    }

    public void m2(){
        try{
            Thread.sleep(5000 );
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        System.out.println( Thread.currentThread().getName() + " m2 " );
    }

    public static void main(String[] args) {
        T_116_02 t = new T_116_02();

        new Thread( t::m1 , "t1" ).start();
        new Thread( t::m2 , "t2" ).start();
    }
}

在这里插入图片描述
//说明是允许被同时调用的。

【模拟银行账户 】：

//是否允许客户读取那些不好的数据。
【允许客户读到不好数据】：
写方法加锁，读方法可以不加锁。
【不允许客户读取不好的数据】：
写、读 方法都加上锁。

/**
 * 面试题：模拟银行账户
 * 对业务写方法加锁
 * 对业务读方法不加锁
 * 这样行不行？
 * <p>
 * 容易产生脏读问题（dirtyRead）
 */

package Ten_Class.t01;

import java.util.concurrent.TimeUnit;

/*
* 【面试题】————模拟银行账户
* 对业务写方法加锁；
* 对业务读方法不加锁；
* 这样行不行？
*
* 容易产生脏读问题（ dirtyRead ）
* */

public class T_116_03_Account {
    String name;
    double balance;

    public synchronized void set(String name, double balance) {
        this.name = name;

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

        this.balance = balance;
    }

    public /*synchronized*/ double getBalance(String name) {
        return this.balance;
    }

    public static void main(String[] args) {
        T_116_03_Account a = new T_116_03_Account();
        new Thread(() -> a.set("zhangsan", 100.0)).start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(a.getBalance("zhangsan"));

        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(a.getBalance("zhangsan"));
    }
}

【 加锁与否 】：

能不加锁就不加锁 ， 加完锁后的效率要低100倍。

【锁的可重入属性】：

synchronized必须是可重入锁；

【例一】:

package Ten_Class.t01;

import java.util.concurrent.TimeUnit;

/*
* 一个同步方法可以调用另外一个同步方法，一个线程已经拥有某个对象的锁，再次申请的时候仍然会得到该对象的锁。
* 也就是说synchronized获得的锁是可重入的。
* */

public class T_117_01 {
    synchronized void m1(){
        System.out.println("m1 start");
        try{
            TimeUnit.SECONDS.sleep(1);
        }catch (InterruptedException e ){
            e.printStackTrace();
        }
        m2();
        System.out.println("m1 end");
    }

    synchronized void m2(){
        try{
            TimeUnit.SECONDS.sleep(2);
        }catch (InterruptedException e ){
            e.printStackTrace();
        }
        System.out.println("----m2----");
    }

    public static void main(String[] args) {
        new T_117_01().m1();
    }
}

【例二】：

package Ten_Class.t01;

import java.util.concurrent.TimeUnit;

public class T_117_02 {
    synchronized void m(){
        System.out.println("m start");

        try{
            TimeUnit.SECONDS.sleep(1);
        }catch(InterruptedException e){
            e.printStackTrace();
        }

        System.out.println("m end");
    }
}

class TT extends T_117_02{

    synchronized void m(){
        System.out.println("child m start");
        super.m();
        System.out.println("child m end");
    }
}

【异常】：

//抛出异常，释放锁，其它想要拿到这把锁的程序会进来。

package Ten_Class.t01;

import java.util.concurrent.TimeUnit;

/*
* 程序在执行过程中，如果出现异常，默认情况锁会被释放；
* 所以，在并发处理的过程中，有异常要多加小心，不然可能会发生不一致的情况；
* 比如，在一个 web app 处理过程中 ， 多个servlet线程共同访问一个资源，这时如果异常处理不合适，
* 在第一个线程中抛出异常，其它线程就会进入同步代码区，有可能会访问到异常产生时的数据。
* 因此要非常小心的处理同步业务逻辑中的异常。
* */
public class T_118_01 {
    int count = 0;
    synchronized void m(){
        System.out.println( Thread.currentThread().getName() + " start " );

        while (true){
            count++;
            System.out.println( Thread.currentThread().getName() + " count = " + count );
            try{
                TimeUnit.SECONDS.sleep(1);
            }catch ( InterruptedException e ){
                e.printStackTrace();
            }

            if (count==5){
                int i = 1/0;  //此处抛出异常 ， 锁将要被释放，要想不被释放，可以在这里进行catch , 然后让循环继续。
                System.out.println( i );
            }
        }
    }

    public static void main(String[] args) {
        T_118_01 t = new T_118_01();
        Runnable r = new Runnable() {
            @Override
            public void run() {
                t.m();
            }
        };

        new Thread( r,"t1").start();

        try{
            TimeUnit.SECONDS.sleep(3);
        }catch (InterruptedException e){
            e.printStackTrace();
        }

        new Thread(r,"t2").start();
    }
}

在这里插入图片描述

无量寂空
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程与并发
qq_33700236的博客
08-10 255
1.缓存一致性问题，如何解决？ 当程序在运行过程中，会将运算需要的数据从主存复制一份到 CPU 的高速 缓存当中，那么 CPU 进行计算时就可以直接从它的高速缓存读取数据和向其中 写入数据，当运算结束之后，再将高速缓存中的数据刷新到主存当中。 比如下面的这段代码： i = i+1 比如同时有 2 个线程执行这段代码，假如初始时 i 的值为 0，那么我们希望 两个线程执行完之后 i 的值变为 2。 可能存在下面一种情况：初始时，两个线程分别读取 i 的值存入各自所在的 CPU 的高速缓存当中，然后线程 1 进
【多线程与高并发】- 浅谈volatile
qq_43843951的博客
02-24 21万+
volatile是Java语言中的一种轻量级的同步机制，它可以确保共享变量的内存可见性，也就是当一个线程修改了共享变量的值时，其他线程能够立即知道这个修改。
【多线程与高并发】- synchronized锁的认知
热门推荐
qq_43843951的博客
02-19 22万+
synchronized 是 Java 语言的一个关键字，它允许多个线程同时访问共享的资源，以避免多线程编程中的竞争条件和死锁问题。
[并发概念] 多线程与高并发
大唐雨夜的博客
12-31 1558
多线程的理解 什么是多线程 如果一个程序允许两个或者两个以上的线程，那么它便是多线程程序。多线程是指单个进程内允许多个线程。 任务分为资源独立任务和资源共享任务。独立任务不需要使用多线程；共享任务，会使用到进程共享资源，需要保证线程安全。 场景理解：房子与租客 假设有一套房子，住着我和我的几个室友，房子比喻进程，我和室友比喻线程。房子中有很多公共空间，例如厨房、客厅，每个人都可以到客厅来。厨房和客...
多线程与高并发实战手册.rar
03-20
综上所述，《多线程与高并发实战手册》是一本全面的指南，它将帮助开发者理解和掌握多线程编程和构建高并发系统的实践技巧。通过深入学习，我们可以提高软件的性能和用户体验，为复杂的企业级应用提供坚实的基础。
多线程与高并发程序
11-27
该资源是马老师在2018年公开课所使用的程序版本，课程中详细的介绍了线程，以及线程和线程池的使用。仅供各位学习和参考使用，希望对大家来说有所帮助。
多线程与高并发-电子.pdf
05-03
马士兵老师课程笔记 https://www.bilibili.com/video/BV1of4y1p74A?p=45
多线程，高并发.pdf
08-15
4. 当一个线程进入一个对象的一个 synchronized 方法后，其它线程是否可进入此对象的其它方法? 5. 简述 synchronized 和 java.util.concurrent.locks.Lock 的异同？ 6. 概括的解释下线程的几种可用状态。
多线程与高并发编程笔记、源码等
09-05
标题“多线程与高并发编程笔记、源码等”表明了资源的核心内容，涵盖了多线程和高并发编程的理论与实践。多线程允许一个应用程序同时执行多个任务，而高并发则指系统能够处理大量并发请求的能力。这两个概念在现代...
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 847
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 702
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
Java内存模型
weixin_44267758的博客
07-19 729
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
java算法day19
TOMOT77的博客
07-20 273
我第一时间想到的方法是遍历二叉树+哈希。哈希用来统计数字出现的次数。之后遍历map收集结果。利用了BST的性质，即BST的中序序列是有序序列。
【Java算法】前缀和 下
2302_79806056的博客
07-18 1142
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
springboot之自动装配
weixin_50153914的博客
07-23 187
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
华为OD机试 - 分披萨 - 递归（Java 2024 D卷 200分）
学Java，找哪吒
07-21 935
递归算法通过函数调用自身解决问题，每次递归调用都处理问题的一个子部分，直到达到基准条件，从而构建最终解。
[Jenkins]jenkins-cli.jar调用用户token启动任务
最新发布
China_Yanhy的博客
07-23 330
jenkins-cli.jar调用用户token启动任务
【Java并发编程之美 | 第三篇】Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
踢桃的成长之路
07-21 782
Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
多线程与高并发 pdf下载
01-02
多线程是一种同时进行多个任务的技术，通过将任务分解成多个子任务，然后将这些子任务分配给不同的线程来同时执行，可以提升程序的性能和效率。而高并发则是指系统能够同时处理大量的请求，通常在网络服务器、数据库...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值