多线程与高并发编程

于 2022-08-12 00:04:49 发布
阅读量465 收藏 1
点赞数
分类专栏： Java基础 文章标签： java 面试 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lfssst/article/details/126295536
版权

多线程与高并发编程一

线程

什么是线程

程序的一条执行路径

public class ThreadDemo {
    public static void main(String[] args) {
        new T1().start();
        for (int i = 0; i<10; i++){
            try {
                TimeUnit.MICROSECONDS.sleep(1);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            System.out.println("main");
        }
    }
    private static class T1 extends Thread{
        @Override
        public void run(){
            for (int i = 0; i<10; i++){
                try {
                    TimeUnit.MICROSECONDS.sleep(1);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
                System.out.println("T1");
            }
        }
    }
}

image-20220712225136894

新建一个线程

public class NewThread {
    //继承thread
    static class MyThread extends Thread{
        @Override
        public void run(){
            System.out.println("HELLO MyThrwad");
        }

    }
    //实现Runnabe
    static class MyRun implements Runnable{

        @Override
        public void run() {
            System.out.println("HELLO MyRun");
        }
    }
    //@Function
    public static void main(String[] args) {
        new MyThread().start();
        new Thread(new MyRun()).start();
        new Thread(()->{
            System.out.println("Hello Lambda");
        }).start();
    }

启动一个线程

//启动线程的方式 1：Thread 2.Runable 3.Executors.newCachedThrad(线程池)实际上也是1、2的一种

image-20220714210145237

状态新建一个线程是 NEW状态（没屌用start），调用start之后之后线程 会被线程调度器来执行整体的状态是Runable状态（内部有ready和Runing俩状态），其中ready是就绪状态， 继续状态就是将线程放到cpu的等待队列当中，真正的放到cpu中运行的是Runing状态，处于Runing状态的线程可以通过yield方法重新回到Ready，直到线程被调度器选中执行重新到Runing状态，执行结束后Teminated状态，到达Teminated不能再次start，也不能回到runable状态

image-20220720233600146

阻塞状态：Blocked 进入synchronized代码块没有获得没有获得锁之前是阻塞状态

等待：waiting 在runable状态是调用了o.wait(time)、t.join(time)、LockSupport.park()进入waiting状态，再调用o.nitify()、o.nitifyAll()、LockSupport.unpark()，又回到Runable状态

时间等待：Timewaiting（时间结束后会自动回去） 在runable状态是调用了Thread.sleep(time)
o.wait(time)、t.join(time)、LockSupport.parkNanos()、LockSupport.parkUntill()时间结束之后自动回到Runable状态

stop（）废除不使用

interrupt 底层会使用没有使用它控制业务逻辑的

synchronized

1.在同一个classloader中的classLoader都是单例模式。

2.一个object只能锁住一个对象

什么时候用到多线程

1.起一个线程 加载图片下载文件

  1. MQ
  2. 小程序体现 防止用户脚本刷

模拟单例模式产生的脏数据

import java.util.concurrent.TimeUnit;

/**
 * @Author:
 * @Date: 2022/08/08/22:09
 * @Description:
 **/
//singletonMode 单例模式
public class 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) {
        Account account = new Account();
        new Thread(() -> account.set("zkj", 100.0)).start();
        try{
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(account.getBalance("zkj"));
        try{
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(account.getBalance("zkj"));
    }

}

image-20220808235405477

new Account的时候就设置了balance这样1s后能读到正确的值100.0，再过2s后能读到正确的值100.0

import java.util.concurrent.TimeUnit;

/**
 * @Author: 
 * @Date: 2022/08/08/22:09
 * @Description:
 **/
//singletonMode 单例模式
public class 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) {
        Account account = new Account();
        new Thread(() -> account.set("zkj", 100.0)).start();
        try{
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(account.getBalance("zkj"));
        try{
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(account.getBalance("zkj"));
    }

}

image-20220808235629037

new Account的时候就没有设置balance，而是等待1s后进行设置balance，这样1s后能不读到正确的值100.0，而是默认值0，再过2s后能读到正确的值100.0

import java.util.concurrent.TimeUnit;

/**
 * @Date: 2022/08/08/22:09
 * @Description:
 **/
//singletonMode 单例模式
public class 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) {
        Account account = new Account();
        new Thread(() -> account.set("zkj", 100.0)).start();
        try{
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(account.getBalance("zkj"));
        try{
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(account.getBalance("zkj"));
    }

}

new Account的时候就没有设置balance，而是等待1s后进行设置balance，但是由于getBalance操作设置的了锁，这样无法读取数据，只能等待设置了值之后，再进行读操作，这样1s后能读到正确的值100.0，而是默认值0，再过2s后能读到正确的值100.0

业务逻辑允许不枷锁就不枷锁 枷锁会影响效率百倍的差距

synchronized可重入的锁

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

import java.util.concurrent.TimeUnit;

/**
 * @Date: 2022/08/09/00:18
 * @Description: 一个同步方法可以调用另外一个同步方法，一个线程已经拥有某个对象的锁，再次申请的时候
 * 仍会得到该对象的锁，也就是说synchronized获得的是可重入的锁
 **/
public class reentrant {
    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() {
        System.out.println("m1 start");
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("m1 end");
    }

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4uc1vByy-1660233819593)(…/Library/Application Support/typora-user-images/image-20220809214249757.png)]

M1（）方法由某线程创建，m2（）也需要枷锁是同一个线程的同一个锁，m2（）也会得到这把锁

eg：image-20220809234840300

如果synchronize不是可重入的锁子类调用父类的方法会死锁

程序在执行过程中，如果出现异常，默认情况锁会被释放

import java.util.concurrent.TimeUnit;

/**
 * @Date: 2022/08/10/21:29
 * @Description:
 **/
public class synceexception {
    /**
     * 程序在执行过程中，如果出现异常，默认情况锁会被释放
     * 所以，在并发处理的过程，有异常要多加小心，不然可能会发生不一致的情况，
     * 比如，在一个web app处理过程中，多个servlet线程共同访问同一个资源，这时如果异常处理不合适
     * 在第一个线程中抛出异常，其他线程就会进入同步代码区，有可能会访问到异常产生时的数据
     * 因此要非常小心的处理同步业务逻辑中的异常
     */
    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) {
        synceexception synceexception = new synceexception();
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                synceexception.m();
            }
        };
        new Thread(runnable,"t1").start();
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(runnable,"t2").start();
    }
}

image-20220811201248830

可见t1抛出异常的同时释放了锁，t2获得了锁

Synchronized 的底层实现（hotspot）

jdk早期的是重量级锁是向操作系统申请的（OS），后来随着java开始有越来越多的高并发的项目，Synchronized的效率就太低了，经过改造才有了现在的锁

现在的锁是有锁升级的概念

偏向锁：sync（Object）如果只有一个线程 只markwoed 记录这个线程ID

自选锁 ：此时如果出现了线程争用这个锁 争用的线程就会自旋起来（默认的次数是10）此时锁升级为自旋锁

重量级锁：10次之后会升级为重量级锁，向OS操作系统申请资源，此时的锁不在占用cpu，变为等待状态，但是锁只能升级不能降级

Atomicl 、lock都是自旋锁，占用cpu但是不访问操作系统，是在用户态处理效率要高于内核态

什么时候使用自旋锁，什么时候用重量级锁（OS进入等待队列）

执行时间长的使用重量级锁，

lfssst
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程与高并发编程基础知识
小白码农的博客
01-16 233
基础概念 进程、线程、纤程 进程相对于程序来说是一个动态的概念，如：QQ、微信等是一个程序，当双击程序时，程序运行起来就是一个进程。作为进程中一个最小的执行单元，就是线程， JUC同步工具 同步容器 线程池 Disruptor框架-单机环境下效率、性能最高 ...
多线程高并发编程(1) -- 基础及详解
07-14 340
进程和线程的区别：进程的内存大小为：**堆内存+线程数量*栈内存，即线程数量 =（ 最大地址空间[MaxProcessMemory] - JVM堆内存 - 系统保留内存[ReservedOsMemory] ）/ ThreadStackSize(XSS)，**从中可以看出，线程的数量随栈内存的增多而减少。线程是程序执行的一个路径，每一个线程都有自己的局部变量表、程序计数器(指向正在执行的指令指针)以及各自的生命周期。当启动了一个Java虚拟机(JVM)时，从操作系统开始就会创建一个新的进程(JVM进程)，JV
多线程与高并发编程进阶（二）
boker_han的博客
09-03 1499
前言：一般来说，Java代码从编写到最后的执行会经历以下的过程：Java源代码（.java文件）–&amp;amp;lt;即时编译器&amp;amp;gt;–Java字节码（.class文件）–&amp;amp;lt;类加载器加载&amp;amp;gt;–汇编指令（CPU执行）；Java中的并发机制依赖于JVM以及CPU指令，这些具体的实现原理将在下面进行分析； 在Java的并发机制中，比较典型也比较常见的两个关键字：volatile以及synchroniz...
多线程高并发编程
qq_34505594的博客
09-04 141
1.countDownLatch 阻塞，countDown到零，结束阻塞继续执行。可以时一个线程countDown，可以是多个线程countDown public static void usingCountDownLatch(){ Thread[] threads = new Thread[100]; CountDownLatch latch = new CountDownLatch(threads.length); for (int i = 0;
多线程与高并发编程笔记、源码等
09-05
超全的多线程与高并发的编程笔记，从JVM&JMM角度讲多线程，synchronized优化原理,AQS和线程池等等，需要的童鞋请自行下载！
Netty多线程并发编程
09-14
Netty多线程并发编程是指在Netty框架中使用多线程技术来实现高性能、高并发的网络编程。下面是关于Netty多线程并发编程的知识点总结： 一、 JAVA 内存模型与多线程编程 在Java中，内存模型是指Java虚拟机（JVM）中...
Java 高并发多线程编程系列案例代码
01-02
Java 高并发多线程编程系列案例代码 & 教程 & 面试题集锦! !! 包括但不限于线程安全性, atomic包下相关类、CAS原理、Unsafe类、synchronized关键字等的使用及注意事项,
深入理解Java多线程与并发编程
08-26
深入理解Java多线程与并发编程 Java多线程与并发编程是Java开发中非常重要的一部分，它涉及到多线程的创建、同步、通信、死锁等问题。下面我们将详细介绍Java多线程与并发编程的相关知识点。 一、多线程三大特性 ...
计算机科学+并发编程+多线程+高性能处理
最新发布
04-25
这款Java高并发多线程处理代码，是计算机科学领域的一次创新实践。它以并发编程和多线程技术为核心，致力于解决高性能处理的需求。无论是开发者、计算机专业学生，还是对高并发多线程技术感兴趣的初学者，都能从中...
多线程与高并发
玉爷的博客
07-11 581
synchronized锁升级： （1）偏向锁（markword 记录这个线程ID） （2）如果有其他线程争用，升级为自旋锁 （3）默认争抢10次以后，重量级锁 - OS 自旋锁占CPU，但是不访问操作系统，在用户态解决所得问题，不经过内核态，所以效率更高。...
多线程与高并发编程进阶（一）
boker_han的博客
09-03 1782
使用多线程的目的：充分利用CPU资源以及加速程序运行速度 使用多线程面临的挑战：上下文切换、死锁、计算机资源的限制等 上下文切换： CPU通过为每个线程分配CPU时间片来实现即使在单核的情况下，依旧可以使用多线程执行代码的机制； 时间片就是CPU的执行时间，通过分配时间片给各个线程，用以执行对应的代码；由于时间片一般很短（几十毫秒左右），所以需要不停地切换线程来使用对应的时间片...
Thread 运行状态
weixin_34347651的博客
03-08 407
2019独角兽企业重金招聘Python工程师标准>>> ...
高并发和多线程的关系
zqhao的博客
03-20 205
“高并发和多线程”总是被一起提起，给人感觉两者好像相等，实则 高并发 ≠ 多线程 多线程是完成任务的一种方法，高并发是系统运行的一种状态，通过多线程有助于系统承受高并发状态的实现。 高并发是一种系统运行过程中遇到的一种“短时间内遇到大量操作请求”的情况，主要发生在web系统集中大量访问或者socket端口集中性收到大量请求（例如：12306的抢票情况；天猫双十一活动）。该情况的发生会导致系统在...
多线程高并发
ZHANGLIZENG的博客
04-15 1823
1.JMM数据原子操作 read(读取)∶从主内存读取数据 load(载入):将主内存读取到的数据写入工作内存 use(使用):从工作内存读取数据来计算 assign(赋值):将计算好的值重新赋值到工作内存中 store(存储):将工作内存数据写入主内存 write(写入):将store过去的变量值赋值给主内存中的变量 lock(锁定):将主内存变量加锁，标识为线程独占状态 unlock(解锁):将主内存变量解锁,解锁后其他线程可以锁定该变量 2.来看volatile关键字 （1）启动两个线程 p
多线程与高并发编程（五）
qq_36268025的博客
04-03 267
多线程与高并发编程（五）一、AQS二、VarHandle三、ThreadLocal（强引用，配合四中的弱引用来读，四、中具体讲了ThreadLocal）四、补充知识五、堆外内存的回收（超纲啦）： 一、AQS AQS内的state状态通过CAS来改变 AQS内的队列的节点添加，也是通过compareAndSetTail（CAS）来改变 双向链表是因为需要看前面节点的状态   CAS操作是针对的ta...
多线程与高并发编程（九）
qq_36268025的博客
04-29 225
多线程与高并发编程（九）一、JMH（测试方法工具）简单介绍1. 测试准备步骤2. 注解二、Disruptor1. 特点：无锁高并发，使用环形Buffer，直接覆盖（不清除）旧的数据，降低GC频率，实现了基于事件的生产者消费者模式（观察者模式）。2. RingBuffer结构：disruptor是利用数组实现的，而且是首尾相连的环形结构（RingBuffer），内部维护一个sequence（代表下一...
java高并发编程详解-第一章多线程基础
NULL
05-30 511
线程介绍 现在几乎100%的操作系统都支持多任务的执行,对计算机来说每一个任务就是一个进程(Process),在每一个进程内部至少要有一个线程(Thread)是在运行中,有时线程也称为轻量级的进程。 线程是程序执行的一个路径,每一个线程都有自己的局部变量表,程序计算器(指向正在执行的指令指针)以及各自的生命周期,现代操作系统中一般不止一个线程在运行,当启动一个java虚拟机,从操作系统开始就会...
java多线程与高并发
05-19
1. 线程池技术：线程池技术是Java中非常重要的高并发编程技术，它可以实现线程的复用，减少线程创建和销毁的开销，提高程序的性能和响应速度。 2. 锁机制：Java中的锁机制包括synchronized关键字、ReentrantLock锁...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值