juc常用方法，线程状态，锁的原理

最新推荐文章于 2024-08-26 16:40:46 发布
最新推荐文章于 2024-08-26 16:40:46 发布
阅读量115 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47448949/article/details/129239588
版权

JUC

线程和进程如何区分

1、进程有独立的内存空间，线程没有，进程是操作系统的基本单位，线程是cpu调度的基本单位

一、线程如何创建

一、继承Thread方法创建

public class T01_WhatIsThread {
    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");
           }
        }
    }

    public static void main(String[] args) {
    	//这种方法就是单纯的方法引用，并没有创建线程
        //new T1().run();
        //通过调用start()方法创建线程进行运行
        new T1().start();
        for(int i=0; i<10; i++) {
            try {
                TimeUnit.MICROSECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("main");
        }

    }
}

二、继承Runnable接口（3种线程调用方法）

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!");
        }
    }

    public static void main(String[] args) {
        new MyThread().start();
        new Thread(new MyRun()).start();
        new Thread(()->{
            System.out.println("Hello Lambda!");
        }).start();
    }

}

三、Executors.newCachedThrad，通过线程池，但是我只了解，不会

二、线程的常用方法

一、Sleep()

改方法运行后会释放cpu资源，等时间结束在继续运行，改方法不会释放锁

    static void testSleep() {
        new Thread(()->{
            for(int i=0; i<100; i++) {
                System.out.println("A" + i);
                try {
                    Thread.sleep(500);
                    //TimeUnit.Milliseconds.sleep(500)
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }

二、yield();

该方法调用时，当前线程重新进入等待队列，该线程重新和其他线程一起等cpu的调度

    static void testYield() {
        new Thread(()->{
            for(int i=0; i<100; i++) {
                System.out.println("A" + i);
                if(i%10 == 0) Thread.yield();


            }
        }).start();

        new Thread(()->{
            for(int i=0; i<100; i++) {
                System.out.println("------------B" + i);
                if(i%10 == 0) Thread.yield();
            }
        }).start();
    }

三、join();

当前线程等待调用的线程执行完毕之后在运行，下列代码中t1会等t2结束在运行

如果没有传参join(),就是得等当前线程运行结束

static void testJoin() {
        Thread t1 = new Thread(()->{
            for(int i=0; i<100; i++) {
                System.out.println("A" + i);
                try {
                    Thread.sleep(500);
                    //TimeUnit.Milliseconds.sleep(500)
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread t2 = new Thread(()->{

            try {
                t1.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            for(int i=0; i<100; i++) {
                System.out.println("A" + i);
                try {
                    Thread.sleep(500);
                    //TimeUnit.Milliseconds.sleep(500)
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        t1.start();
        t2.start();
    }

三、线程状态

一、status（）；

当前线程的状态信息，3中，Ready（等待运行）Running(运行中)和Teminated（运行结束）

注意，线程没有关闭线程一说，因为关闭线程stop()方法会出问题，所以非必要不运行，等运行结束关闭就可以了

在这里插入图片描述

四、synchronized锁

1、synchronized是针对对象头两位锁的，多个线程都是看对象头的两个直接是否上锁，所以锁的时候，不能让对象重新初始化，所以用final修饰。

2、不能用String常量，

3、老的jdk版本中，synchronized直接是重量级锁，但是因为现实过程中，可能出现多个线程抢占锁的时候，同一个线程在释放锁之后又重新获取锁，所以对synchronized进行了优化操作，出现了偏向锁，自旋锁，重量级锁的升级操作，就是当线程1释放了锁，记录下这个线程1的信息，释放完立马在和别人竞争锁时，直接选择线程1，如果线程1没有抢到锁，升级为自旋锁，就是我在这自己绕圈，等我自旋完看你是否释放，释放了我就抢占锁，没有释放我就不抢占锁，如果自旋完原来占有的线程没有释放，那么就升级为重量级锁。

​ 3.1、线程数如果多的话，大量的线程数在自旋占用资源，那么效率可能会更低，线程数如果比较正常，或者少，那么自选锁对资源的占用就比较少。

​ 3.2、synchronized因为锁升级的概念，所以效率未必会比其他锁效率低

synchronized实现i++的思路

在这里插入图片描述

五、volatile

1、保证线程可见性，看下面代码，分析加volatile和不加的区别

​ 1.1：在新建线程时，线程中的值会去copy公共地方的变量，靠cpu的缓存一致性MESI才能实现

​ 1.2：没有volatile是线程之间的可见性是不保证的，子线程更改了东西会立马同步到公共区域，但是不会同步到其他子线程中


public class T01_HelloVolatile {
	volatile boolean running = true; //对比一下有无volatile的情况下，整个程序运行结果的区别
	void m() {
		System.out.println("m start");
		while(running) {
		}
		System.out.println("m end!");
	}

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

		new Thread(t::m, "t1").start();

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

		t.running = false;
	}

}

2、禁止指令重排序

​ cpu层面禁止不了，jvm虚拟机可以禁止，这个基于现在的cpu的指令重排序命令来优化的，原本的cpu是单个命令，直接就运行了，现在的cpu为了提高效率，对于一些指令进行优化，有些指令可能会运行时同时运行，这就导致了工作上面的

双重锁在超高的并发中，会出现问题。

jvm的new对象过程，

​ 1、申请内存，给到默认值

​ 2、内存中设置我们的定义值

​ 3、把内存绑定给代码中的对象，

​ 因为CPU的指令重排序，偶尔会出现1 3 2的情况，单例模式下的双重锁，当第一个进去了，在创建对象时，1，3完成赋值了，而2还没有完成，另一个进程拿的这个对象去操作了，会出现值不对的情况，出现问题

​ volatile 关键字，使一个变量在多个线程间可见

volatile虽然保证了线程可见，但是不能保证原子性，不能替换synchronized

如果只有volatile发现i++不是10000，但是synchronized可以保证是10000条数据


public class T04_VolatileNotSync {
	/*volatile */int count = 0;
	synchronized void m() {
		for(int i=0; i<10000; i++) count++;
	}

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

		List<Thread> threads = new ArrayList<Thread>();

		for(int i=0; i<10; i++) {
			threads.add(new Thread(t::m, "thread-"+i));
		}

		threads.forEach((o)->o.start());

		threads.forEach((o)->{
			try {
				o.join();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		});

		System.out.println(t.count);


	}

}

AtomicLong多线程i++无锁化操作线程安全

AtomicLong,AtomicInteger,底层用的CAS无锁化

CAS（Compare And Set）无锁化

在这里插入图片描述

CAS是CPU原语支持，中间不可以被打断，所以在更改的时候不会出现第二个

cas(更改的对象，期望值，更新值)；每个线程都会输入一个原来的值，一个要改变的值，当发现原来的值和输入不一样，那就是有线程改变了这个值，我循环等上一个线程改变，我在输入一个新的原来的值，一个新的改变到的值。

AbA问题：

会出现aba的问题，在上一个cas操作的时候变成b又变成1，第二个线程也不会有问题，不改也没事，不过想要解决这个问题，加版本号，后面在检查是加上版本号处理

aba问题出现，如果是基本数据类型，那没有问题，怎么样都行

如果是处理对象，就需要解决

举例：刚开始执行一个对象a，对象a中有个引用属性b，我cas(a,a,b)期望值改成b，并且改成b的时候，b中的属性变更了一点，然后我又cas（b,b,a）这么着下来，我们去比较a的时候，a是没有问题的，但是a指向的b的属性值有了问题，后续业务逻辑出错

public class T01_AtomicInteger {
   /*volatile*/ //int count1 = 0;
   
   AtomicInteger count = new AtomicInteger(0); 

   /*synchronized*/ void m() { 
      for (int i = 0; i < 10000; i++)
         //if count1.get() < 1000
         count.incrementAndGet(); //count1++
   }

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

      List<Thread> threads = new ArrayList<Thread>();

      for (int i = 0; i < 10; i++) {
         threads.add(new Thread(t::m, "thread-" + i));
      }

      threads.forEach((o) -> o.start());

      threads.forEach((o) -> {
         try {
            o.join();
         } catch (InterruptedException e) {
            e.printStackTrace();
         }
      });

      System.out.println(t.count);

   }

}

LongAdder多线程i++分段锁操作

i会变成一个数组分别上锁，每个数组元素都加锁，由全部的线程平均分到数据的各个节点上，然后由最后的结果获取

在这里插入图片描述

/**
 * 解决同样的问题的更高效的方法，使用AtomXXX类
 * AtomXXX类本身方法都是原子性的，但不能保证多个方法连续调用是原子性的
 * @author mashibing
 */
package com.mashibing.juc.c_018_00_AtomicXXX;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.LongAdder;


public class T01_AtomicInteger {
   /*volatile*/ //int count1 = 0;

// AtomicInteger count = new AtomicInteger(0);
   LongAdder count = new LongAdder();

   /*synchronized*/ void m() {
      for (int i = 0; i < 10000; i++)
         //if count1.get() < 1000
         count.increment(); //count1++
   }

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

      List<Thread> threads = new ArrayList<Thread>();

      for (int i = 0; i < 10; i++) {
         threads.add(new Thread(t::m, "thread-" + i));
      }

      threads.forEach((o) -> o.start());

      threads.forEach((o) -> {
         try {
            o.join();
         } catch (InterruptedException e) {
            e.printStackTrace();
         }
      });

      System.out.println(t.count);

   }

}

Atomic与synchronized与longAdder性能测试程序

根据下列程序，可以看到AtomicLong的效率要高于sync，但是要低于LongAdder，因为LongAdder在特别多的线程情况下，效率是比较高的，而AtomicLong是因为cas乐观锁，效率是比较高的，sync锁升级，在升级之后效率是很低的。

package com.company.test020;

import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.LongAdder;

/**
* @description: TODO
* @author yang.su
* @version 1.0
*/
public class AtomicVsSyncVsLongAdder {
    static Long count3 =0L;
    static AtomicLong count1 = new AtomicLong(0);
    static LongAdder count2  = new LongAdder();
    public static void main(String[] args) throws Exception {


        final Object lock =  new Object();
        Thread[] threads = new Thread[1000];
        //AtomicLong测试
        for (int i = 0 ; i<threads.length ; i++){
            threads[i] = new Thread(()->{
                for (int j = 100000 ; j>0 ; j--){
                    count1.incrementAndGet();
                }
            });
        }
        long atomicStart = System.currentTimeMillis();
        for (Thread thread : threads) {
            thread.start();
        }
        for (Thread thread : threads) {
            thread.join();
        }
        long atomicEnd = System.currentTimeMillis();
        System.out.println("atomicLong"+count1+":"+(atomicEnd-atomicStart));

        //LongAdder
        for (int i = 0 ; i<threads.length ; i++){
            threads[i] = new Thread(()->{
                for (int j = 100000 ; j>0 ; j--){
                    count2.increment();
                }
            });
        }
        long longAdderStart = System.currentTimeMillis();
        for (Thread thread : threads) {
            thread.start();
        }
        for (Thread thread : threads) {
            thread.join();
        }
        long longAdderEnd = System.currentTimeMillis();
        System.out.println("longAdder"+count2+":"+(longAdderEnd-longAdderStart));

        //sync
        for (int i = 0 ; i<threads.length ; i++){
            threads[i] = new Thread(()->{
                for (int j = 100000 ; j>0 ; j--){
                    synchronized (lock){
                        count3++;
                    }

                }
            });
        }
        long syncStart = System.currentTimeMillis();
        for (Thread thread : threads) {
            thread.start();
        }
        for (Thread thread : threads) {
            thread.join();
        }
        long syncEnd = System.currentTimeMillis();
        System.out.println("sync"+count2+":"+(syncEnd-syncStart));

    }
}

      synchronized (lock){
                    count3++;
                }

            }
        });
    }
    long syncStart = System.currentTimeMillis();
    for (Thread thread : threads) {
        thread.start();
    }
    for (Thread thread : threads) {
        thread.join();
    }
    long syncEnd = System.currentTimeMillis();
    System.out.println("sync"+count2+":"+(syncEnd-syncStart));

}

}

weixin_47448949
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JUC常用知识小结
Cscprx的博客
04-13 322
本文是参照b站狂神说java总结的一些知识点 JUC synchronize八锁问题 synchronize 的六种锁的情况 详情请看代码里面的注释 第一种 package lock; import java.util.concurrent.TimeUnit; /** * synchronize 锁住两个方法 * 结果先发短信，在打电话 * 原因： 因为synchronize ...
JUC学习一（两种保证线程安全的方式）
tianqiztq的博客
10-30 183
多线程中常用的两种确保线程安全的方式 ①、synchronized的方式（用于代码块或者方法上面） ②、Lock锁的方式 下面以卖票为案例 文章目录一、卖票的案例代码？二、synchronized和Lock的区别 一、卖票的案例代码？ //利用synchronized修饰方法达到线程安全 public class SaleTicketSynchronizedMethod { public static void main(String[] args) { Ticket1 t.
JUC（Java.util.concurrent）是Java中的一个包，提供了一些并发编程的工具类和接口
BLOG域名:programb.blog.csdn.net
01-31 588
JUC（Java.util.concurrent）是Java中的一个包，提供了一些并发编程的工具类和接口，用于简化多线程编程的开发。JUC包含了许多并发编程的高级特性，如线程池、并发集合、原子变量、锁等，可以帮助开发者更方便地实现并发控制和线程安全。
JUC的常见类
qq_65291053的博客
08-27 118
也是一种创建线程的方式Runnable 能表示一个任务(run方法),返回voidCallable 也能表示一个任务(call方法),返回一个具体的值,类型可以通过泛型参数来指定(object)如果进行多线程操作,如果你只是关心多线程的执行过程,使用Runnable即可,如果是关心多线程的计算结果,使用Callable更合适使用Callable不能直接作为Thread的构造方法参数,我们可以借用FutureTask来完成。
并发队列阻塞式与非阻塞式的区别
dianbiao3588的博客
05-02 317
在并发队列上JDK提供了两套实现，一个是以ConcurrentLinkedQueue为代表的高性能队列非阻塞，一个是以BlockingQueue接口为代表的阻塞队列，无论哪种都继承自Queue。 队列遵循先进先出，后进后出的原则。 阻塞式队列比非阻塞式队列性好。 阻塞式队列与非阻塞队列的区别： 阻塞式队列： 入列(存)：阻塞式队列，如果存放的队列超出队列的总数，是时候会进行...
剑指JUC原理-3.线程常用方法及状态
爱吃知识的土豆倪的博客
10-26 646
直接调用run是在主线程中执行了run，并没有启用新的线程，而使用start是启动新的线程，通过新的线程简介执行了run中的代码。
多线程CAS、synchronized锁原理 、JUC以及死锁
m0_68989458的博客
07-17 231
多线程CAS、synchronized锁原理 、JUC以及死锁
JUC并发多线程进阶
早上真起不来的博客
06-09 286
笔记整理来源 B站UP主狂神说Java https://space.bilibili.com/95256449/ JUC并发多线程进阶 1、什么是JUC 源码+官方文档 JUC是 java util concurrent 面试高频问JUC~！ java.util 是Java的一个工具包~ 业务：不会通过普通的线程代码 Thread 来实现 Runnable： 没有返回值、效率相比于Callable 相对较低！ 2、线程和进程 进程：一个程序，QQ.exe Music.exe；数据+代码+pcb 一个进程可
多线程之JUC
m0_57698935的博客
09-27 498
多线程之JUC 1、什么是JUC？ JUC是java.util.concurrent的简写 在jdk官方手册中可以看到JUC相关的jar包有三个。 JUC的意思就是java并发编程工具包 并发编程的本质就是充分利用CPU资源 进程、线程 进程 进程是指在系统中正在运行的一个应用程序，程序一旦运行就是进程。 进程是系统进行资源分配的独立实体， 且每个进程拥有独立的地址空间。 一个进程可以拥有多个线程，每个线程使用其所属进程的栈空间。 线程 线程是进程的一个实体，是进程的一条执行路径。 线程是CPU独立运行和独
JUC 多线程
m0_46499246的博客
03-30 240
JUC 多线程介绍 1、 线程的生命周期 新建状态（New）：当线程对象对创建后，即进入了新建状态，如：Thread t = new MyThread(); 就绪状态（Runnable）：当调用线程对象的start()方法（t.start();），线程即进入就绪状态。处于就绪状态的线程，只是说明此线程已经做好了准备，随时等待CPU调度执行，并不是说执行了t.start()此线程立即就会执行； 运行状态（Running）：当CPU开始调度处于就绪状态的线程时，此时线程才得以真正执行，即进入到运行状
多线程和JUC
weixin_44093711的博客
11-12 1282
进程 进程就是正在运行的程序，是系统进行资源分配和调用的独立单位。每一个进程都有他自己的内存空间和系统资源 多进程意义在于计算机可以执行多个任务，提高cpu使用率 我们在一边玩游戏，一边听音乐的时候，是cpu在做着程序间的高效切换让我们觉得是同时进行的 线程 线程是依赖于进程而存在的，在一个进程内又可以执行多个任务，而这每个任务我就可以看出是一个线程 线程：是程序的执行单元，执行路径。是程序使用cpu的最基本单位。 单线程：程序只有一条执行路径 多线程：程序有多条执行路径 多线程意义在于提高应用程序的使用率
java--JUC快速入门（彻底搞懂JUC）
热门推荐
weixin_43888181的博客
05-08 10万+
java–JUC快速入门（彻底搞懂JUC） 文章目录java--JUC快速入门（彻底搞懂JUC）1、学习多线程之前需要知道的一些概念。2、JUC的结构3、Lock锁(重点)4、集合类不安全5、Callable()6、常用的辅助类7、读写锁8、阻塞队列9、线程池 1、学习多线程之前需要知道的一些概念。 1.1 JUC是什么？ JUC是java.util.concurrent包的简称，在Java5.0添加，目的就是为了更好的支持高并发任务。让开发者进行多线程编程时减少竞争条件和死锁的问题！...
Java - JUC详解
S mile0804的博客
04-02 5645
一、概述 1.1 什么是JUC？ JUC是java.util.concurrent包的简称，在Java5.0添加，目的就是为了更好的支持高并发任务。让开发者进行多线程编程时减少竞争条件和死锁的问题！ 1.2 什么是进程？ 程序由指令和数据组成，但这些指令要运行，数据要读写，就必须将指令加载至CPU，数据加载至内存。在指令运行过程中还要用到磁盘、网络等设备。进程就是用来加载指令，管理内存管理IO的。 当一个进程被运行，从磁盘加载这个程序的代码至内存，这时就开启了一个进程。 进程就可以视为一个实例。
JUC基本知识
qq_41891805的博客
08-10 595
一、Lock接口 1）、多线程涉及到的基本概念 资源类、操作、线程、高内聚、低耦合 2）、使用 ①实现类 ReentrantLock（可重入锁） ②基本方法 lock() 上锁、unlock() 解锁 二、线程间通信 1）、经典问题 生产者&&消费者 Ps：注意多线程之间的虚假唤醒 解决：对于wait()方法使用循环判断 2）、使用synchronized 对应方法：wait（）、notify（） 3）、使用lock await()、signal() Ps：让当前线程睡眠：TimeUnit
阿里云服务器 篇七：服务器热备份/定时备份
生活在别处
08-24 521
Python 客户端用于百度云（个人云存储）百度云/百度网盘 Python 客户端。它主要用于在 Linux 环境下通过命令行操作百度云盘的 2TB 存储空间。是一个Github开源项目，这是一个百度云/百度网盘Python客户端。: 列出百度 PCS 中的 ‘remotepath’ 目录。: 从本地目录同步到远程目录。: 在百度云中创建一个目录。
启动Application 报错：no mapping for GET /（已解决）
最新发布
qq_3512323979的博客
08-26 586
no mapping for GET /因为我使用的是框架嘛，然后生成了一个SpringBoot项目后，resources下面就会有一个static的类，用于存放静态资源类，后面我把静态资源放在里面，但是启动启动类后，报错一直匹配不到。： 正常的话，我们使用SpringBoot框架，他会给我们提供许多便利，包括静态资源的自动服务，默认的话，他会去。报这个错可能还有其他原因，我的是因为这个，大家可以根据日志信息一步步检查，肯定可以解决的！类并覆盖其方法时，就会失去静态资源的自动服务
开发多线程程序时，需要注意那些问题
OO_SEN的博客
08-23 1005
线程安全 竞态条件（Race Condition）：当多个线程同时访问和修改共享资源时，可能会出现竞态条件，导致不确定的行为。需要通过同步机制（如互斥锁、读写锁、原子操作）来保护共享资源。 死锁（Deadlock）：当两个或多个线程相互等待对方释放锁时，程序会陷入死锁状态。避免死锁的一些策略包括：避免嵌套锁、确保加锁顺序一致、使用超时机制等。 活锁（Livelock）：与死锁不同，活锁是指线程不断地尝试获取资源但总是失败，导致无法继续执行。避免频繁重试操作或使用退避算法可以减少活锁的发生。 优先级反转（P
笔记redis
风止的博客
08-22 1528
Redis（Remote Dictionary Server）是用C语言开发的一个基于的数据库。
Java JUC并发编程实例：守护线程与Synchronized锁
本资源主要介绍Java并发编程中的Java.util.concurrent (JUC) 库，以及多线程和同步机制。首先，我们探讨了用户线程与守护线程的区别。在Java中，用户线程（非守护线程）是主线程执行的主要工作单元，它们不会自动随...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值