java juc1

最新推荐文章于 2024-01-21 22:00:07 发布
最新推荐文章于 2024-01-21 22:00:07 发布
阅读量181 收藏
点赞数 1

一、volitale关键字

1. volitale可以保证线程共享数据的内存可见性,也就是说,数据被修改之后,其他线程读取该数据的时候,会直接从主内存里面读取,所以读取的是最新数据;

2.volitale的性能比加锁的性能高,相对于synchronized 是一种较为轻量级的同步策略;

3.缺陷

  a:volitale不能保证数据的"原子性";

  b:volitale 不能保证线程''互斥性'',也就是不能保证多个线程一次只能一个线程访问共享变量;

4.解决使用volatile时原子性问题,jdk1.5之后提供了java.util.concurrent.atomic包下提供了,常用原子变量:

a:volitale保证了内存可见性

b:CAS算法保证了原子性

CAS算法原理:在线程启动的时候,会读取一次共享变量标记为V,当此线程对该变量进行读写操作的时候,会进行再次读取标记为A,当且紧当V=A的时候,才会对变量进行更新操作。

 

二，CAS算法模拟

 

public class CAS {
    public static void main(String[] args) {
        final CompareAndSwap compareAndSwap = new CompareAndSwap();
        for (int a = 0; a < 10; a++) {
            new Thread(new Runnable() {
                public void run() {
                    int oldValue = compareAndSwap.getValue();
                        boolean aBoolean = compareAndSwap.compare(oldValue, (int) (Math.random()*101));
                    System.out.println(Math.random() * 101);
                        System.out.println(aBoolean);
                }
            }).start();
        }

    }
}
class CompareAndSwap {
    private  int value;

    public CompareAndSwap(int value) {
        this.value = value;
    }

    public CompareAndSwap() {
    }

    public synchronized int getValue() {
        return value;
    }

    public synchronized int setValue(int oldValue, int newValue) {
 
 
//getValue()为主内存的值,oldValue为预估值(第一次取得的值)

if (getValue() == oldValue) { oldValue = newValue; } return oldValue; }

public  synchronized boolean compare(int oldValue, int newValue){
    if (oldValue == setValue(oldValue, newValue)) {
        return true;
    }
    return false;
 }

}

 
三、锁分段机制

 

1，concurrentHashMap 采用了锁分段机制，允许多个线程并发访问，并且线程安全，所以效率较高。由于其底层也是通过加锁机制来保证线程安全，但是CAS是无锁操作，效率更高。所以，后来JVM也是采用CAS算法。

2，CopyOnWriteArraySet /CopyOnWriteArrayList:"写入并复制"

注意:添加操作多时,每次添加都会复制一次,开销比较大,迭代并发是适合选择;

 

四、闭锁CountDownLatch一个同步辅助类,当其他所有线程都执行结束以后，才会开始执行

 

public class TestCountDownLatch {

    public static void main(String[] args) {
        CountDownLatch countDownLatch = new CountDownLatch(5);
        OfCountDownLatch ofCountDownLatch = new OfCountDownLatch(countDownLatch);
        long start = System.currentTimeMillis();
        for (int i = 0; i < 5; i++) {
            new Thread(ofCountDownLatch).start();
        }
        try {
            countDownLatch.await();//等待其他方法执行结束
        } catch (InterruptedException e) {
        }
        long end = System.currentTimeMillis();
        System.out.println("五个线程耗时:"+(end - start));

    }

}
public class OfCountDownLatch implements Runnable{
    private CountDownLatch countDownLatch;

    public OfCountDownLatch(CountDownLatch countDownLatch) {
        this.countDownLatch = countDownLatch;
    }

    public void run() {
        synchronized (this) {
            try {
                for (int i=0;i<50000;i++) {
                    if (i % 2 == 0) {
                        System.out.println(i);
                    }
                }
            }finally {
                countDownLatch.countDown();
            }
        }
    }
}

执行结果:

 

49992
49994
49996
49998

......

49992
49994
49996
49998

五个线程耗时:1104

 

五、callable接口

 

public class TestCallable {
    public static void main(String[] args) {
        CallableDemo callableDemo = new CallableDemo();
        FutureTask<Integer> futureTask = new FutureTask<Integer>(callableDemo);
        for (int i = 0; i < 10; i++) {
            new Thread(futureTask).start();
        }
        try {
            Integer result=futureTask.get();
            System.out.println(result);
            System.out.println("...................");//打印位置可以判断,callable接口也可以实现封闭锁
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}
public class CallableDemo implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        int sum=0;
        for (int a=0;a<=1000;a++) {
            if (a % 10 == 0) {
                sum+=a;
            }
        }
        return sum;
    }
}

结果：

 

50500
...................

 

六、同步锁

1、多线程安全解决方法：

 jdk1.5之前(synchronized隐式锁)

a、同步方法

b、同步代码块

2、jdk1.5之后使用同步锁

lock()上锁和unlock()释放锁

unlock()必须在finally使用来确保必须执行

 

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Created by 13795 on 2017/9/18.
 */
public class LockTicket implements Runnable{
    static int ticket=100;
    Lock lock = new ReentrantLock();
    @Override
    public void run() {
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
        }
        try {
            lock.lock();
            while (true) {
                if (ticket > 0) {

                    System.out.println(Thread.currentThread()+"当前余票为:"+ --ticket);
                }
            }
        }finally {
            lock.unlock();
        }

    }
}
public class LockTest {
    public static void main(String[] args) {

        LockTicket ticket=new LockTicket();

        new Thread(ticket,"一号窗口").start();
        new Thread(ticket,"二号窗口").start();
        new Thread(ticket,"三号窗口").start();
        new Thread(ticket,"四号窗口").start();
        new Thread(ticket,"五号窗口").start();
    }
}

结果:

 

Thread[一号窗口,5,main]当前余票为:100
........

Thread[一号窗口,5,main]当前余票为:6
Thread[一号窗口,5,main]当前余票为:5
Thread[一号窗口,5,main]当前余票为:4
Thread[一号窗口,5,main]当前余票为:3
Thread[一号窗口,5,main]当前余票为:2
Thread[一号窗口,5,main]当前余票为:1
Thread[一号窗口,5,main]当前余票为:0

 

七,虚假唤醒

线程通讯的时候,需要将wait放在循环里面,以防止虚假唤醒

 

  • A thread can also wake up without being notified, interrupted, or timing out, a so-calledspurious wakeup. While this will rarely occur in practice, applications must guard against it by testing for the condition that should have caused the thread to be awakened, and continuing to wait if the condition is not satisfied. In other words, waits should always occur in loops, like this one:

         synchronized (obj) {
         while (<condition does not hold>)
             obj.wait(timeout);
         ... // Perform action appropriate to condition
     }

public class TestOfProducterAndCustmer {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();
        Producter pro = new Producter(clerk);
        Customer cus = new Customer(clerk);
        new Thread(pro,"生产者一").start();
        new Thread(pro,"生产者二").start();
        new Thread(cus,"消费者三").start();
        new Thread(cus, "消费者四").start();
    }
}
public class Clerk {
    private int count=0;

    /**
     * 生产者消费者
     */

    public synchronized void  get(){
        while (count >= 1){
            System.out.println("货满");
            try {
                this.wait();
            } catch (InterruptedException e) {
            }
        }
            System.out.println(Thread.currentThread() + "生产后货品数量:" + ++count);
            this.notifyAll();
    }


    public synchronized void sall() {
        while (count <=0) {
            System.out.println("缺货");
            try {
                this.wait();
            } catch (InterruptedException e) {
            }
        }
        System.out.println(Thread.currentThread() + "消费后产品数量:" + --count);
        this.notifyAll();
    }

}
public class Customer implements Runnable {

    Clerk clerk = new Clerk();
    public Customer(Clerk clerk) {
        this.clerk = clerk;
    }
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            clerk.sall();
        }
    }
}
public class Producter implements Runnable{
    Clerk clerk = new Clerk();

    public Producter(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
        }
        for (int i = 0; i < 20; i++) {
            clerk.get();
        }
    }
}

 

 

 

八,Condetion

使用Lock的时候可以使用需要使用Condetion进行线程通信,方法为

lock.newCondition()如下

 

 

private Condition condition = lock.newCondition();

Condetion有自己对应的线程通信方法 

1, condition.await();
2, condition.signal();
3,condition.signalAll();

 

 

 

 

 

 

 

 

changzhi_li
关注
Java 之 JUC
weixin_34160277的博客
11-11 318
1. JUC 简介 在 Java 5.0 提供了 java.util.concurrent(简称JUC)包,在此包中增加了在并发编程中很常用的工具类, 用于定义类似于线程的自定义子系统,包括线程池,异步 IO 和轻量级任务框架;还提供了设计用于多线程上下文中 的 Collection 实现等; 2. volatile 关键字 volatile 关键字: 当多个线程进行操作共享数据时,可以保证...
JUC包下的几个辅助类
qq_32302897的博客
08-14 1492
1、semaphore Semaphore中文解释成信号量的意思，可以看成一个可获数量有限的共享锁。锁只可被有限数量线程使用。 这个辅助类的核心方法是acquire以及release方法。acquire方法用于获取许可，release用于归还一个许可。 acquire方法其默认调用的是非公平的获取方法。意思也就是每当执行一次这个acquire方法，便会将你指定的avaliable(你指定的数...
JUC-1. volatile关键字与内存可见性
xbliu564的博客
03-03 255
一、volatile关键字 适用：当多个线程共享一个变量时，如果有一个线程修改此变量，其他线程读取此变量值。 特性： 内存可见性。 阻止重排序。 注意： 只能确保变量可见性，并不能确保原子性。 volatile不具备“互斥性”。 3. 应用示例 volatile保证了数据可见性。性能比synchronize效率高。 /** * 关键字：volatil...
JUC (一) ——集合类
luotuomianyang的博客
08-02 3412
阿里电面的时候被问到JUC,刚好木有看完...感觉被鄙视了  哭....好好看书学习...             下面，我们先了解JUC包中集合类的框架；为了方便讲诉，我将JUC包中的集合类划分为3部分来进行说明。在简单的了解JUC包中集合类的框架之后，后面的章节再逐步对各个类进行介绍。 1.List和Set JUC集合包中的List和Set实现类包括: Copy
J.U.C框架学习顺序
chen7253886的博客
10-09 2658
背景        Java concurrent包提供了很多高性能的并发类，类的设计思路及源码值得我们学习参考，但在学习其原理过程中，作者经常碰到这种情况，在学习ConcurrentHashMap时，里面的部分方法操作牵扯到其他类，例如Unsafe、ReentrantLock，又需要了解ReentrantLock，进而又去学习AQS原理，导致整个学习过程非常的复杂，没有条理性，所以本文主要介绍根据
Java - JUC详解
S mile0804的博客
04-02 5824
一、概述 1.1 什么是JUC？ JUC是java.util.concurrent包的简称，在Java5.0添加，目的就是为了更好的支持高并发任务。让开发者进行多线程编程时减少竞争条件和死锁的问题！ 1.2 什么是进程？ 程序由指令和数据组成，但这些指令要运行，数据要读写，就必须将指令加载至CPU，数据加载至内存。在指令运行过程中还要用到磁盘、网络等设备。进程就是用来加载指令，管理内存管理IO的。 当一个进程被运行，从磁盘加载这个程序的代码至内存，这时就开启了一个进程。 进程就可以视为一个实例。
java——juc篇
Michael_Jay的博客
01-21 1444
本篇文章汇总了java并发编程的常见八股文
Java JUC概述
果酱 の 博客
06-20 4359
Java JUC 提供了一系列的工具类和接口，用于简化多线程编程。在实际开发中，我们应该根据具体的业务需求选择合适的工具类和接口，以提高程序的并发性能和可靠性。同时，我们还应该遵守多线程编程的最佳实践，如避免死锁、竞态条件等问题，以确保程序的正确性和稳定性。
Java——JUC
12-29
Java并发编程是Java开发中的重要领域，而Java并发工具包（Java Concurrency Utility，简称JUC）则是Java标准库提供的一套强大而丰富的工具，它极大地简化了多线程环境下的编程工作。JUC主要包含在`java.util....
Java JUC包 思维导图总结1
03-25
自己学习过程对Java JUC包知识的总结，看完并理解基本能应付各种基本的问题点，墙裂推荐分享 博客跳转链接： https://blog.csdn.net/qq_35642036/article/details/82767070
基于Java JUC框架的售票系统与多线程锁通信设计源码
09-30
该项目为Java JUC框架下的售票系统设计源码，包含25个文件，其中包括23个Java源文件、1个属性文件和1个XML文件。项目涵盖了乘务员售票、一锁八式、Lock锁和多线程通信等多线程技术实践，旨在通过源码学习提升并发...
java juc面试题一般问什么？juc面试分析
javase1085的博客
03-08 2700
对程序员来说，最重要的一个门槛就是面试了，虽然常有面试造核弹，工作拧螺丝的说法，但该要的面试还是要的，这里整理了一些java中juc相关面试题，快来了解下吧。 一、juc具体是? Java 5.0 提供了java.util.concurrent(简称JUC)包，在此包中增加了在并发编程中很常见的实用工具类，用于定义类似于编程的自定义子系统，包括线程池、异步IO和轻量级任务框架。提供可调的、灵活的线程池。还提供了设计用于多线程上下文的Collection实现等。 二、什么是CAS? CAS(Compare-A
Java并发编程面试题——JUC专题
二蛋的博客
02-20 7476
1.1AQS是什么？1.2唤醒线程时，AQS为什么从后往前遍历？1.3AQS为什么用双向链表，（为啥不用单向链表）？1.4AQS为什么要有一个虚拟的head节点1.5ReentrantLock的底层实现原理1.6ReentrantLock的公平锁和非公平锁的区别1.7ReentrantReadWriteLock如何实现的读写锁2.1说下你熟悉的阻塞队列？2.2虚假唤醒是什么？3.1线程池的7个参数3.2线程池的状态有什么，如何记录的？3.3线程池常见的拒绝策略3.4线程池执行流程3.5线程池为什么添加空任务
JUC(一) 基本概念
程序员XW
07-24 1478
1.并行的世界 并行在图像处理和服务端程序中有着广泛的应用 2.你必须知道的几个概念 同步： 买空调，买完之后在商店等待，知道商家把你和空调一起送回家，愉快的结束了 异步： 买空调，在网上下单，支付完成后，对你来说整个的过程便已经结束了，虽然没收到货但是你的任务完成了，剩下的时候你就等待收获即可以了 这期间你想干什么就干什么 并发：偏重与多个任务交替执行，而多个任务有可能还是串行的，...
三维重建-基于Matlab实现结构光三维重建算法-优质项目分享.zip
最新发布
10-17
三维重建_基于Matlab实现结构光三维重建算法_优质项目分享
云网络验证系统云验证+卡密生成+多应用多用户管理
10-17
云网络验证系统云验证，多样化应用管理方式，多种项目任你开发，分布式应用开关，让您的应用开发更简单，本系统借鉴于易如意API写法及思路，完美实现多用户多应用管理。 源码特色 1，对接：详细的API文档，各种语言对接示例让您的接入更加简单 2，安全：客户端与服务器双向效验，动态数据加密，让您的数据“动起来” 3，API：各种API尽情对接，让您的应用大放光彩 4，快捷：后台一键式开关，应用版本，远程更新，更新内容等，让您更快捷更省心 5，功能：丰富的功能，各类数据统计，人性化的体验，满足您的更多需求 6，其他：内置商城、聊天室、工单等，我们将致力于给您最好的体验，如有任何问题都可以向我们反馈 支持多应用卡密生成 卡密生成 单码卡密 次数卡密 会员卡密 积分卡密 卡密管理 卡密长度 卡密封禁 批量生成 批量导出 自定义卡密前缀等 支持多应用多用户管理 应用备注 应用版本 多级代理价格 免费付费切换 验证用户IP 验证用户设备 应用开关等
毕业设计论文SpringBoot社区待就业人员信息管理系统.docx
10-17
毕业设计论文
爱心商城系统 JAVA毕业设计 源码+数据库+论文 Vue.js+SpringBoot+MySQL.zip
10-17
爱心商城系统 JAVA毕业设计 源码+数据库+论文 Vue.js+SpringBoot+MySQL 系统启动教程：https://www.bilibili.com/video/BV11ktveuE2d
微积分极限、线代行列式小测.zip
10-17
微积分极限、线代行列式小测.zip
Java JUC并发编程高级教程
"22 尚硅谷Java JUC线程高级视频" Java JUC（java.util.concurrent）是Java 5.0及以后版本引入的一个重要包，专门用于提升并发编程的效率和可管理性。这个包包含了一系列工具类和接口，旨在简化多线程编程，提高...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值