JUC 并发编程学习（2）

原创 于 2020-12-03 18:07:51 发布
· 168 阅读 · 0 ·
版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java

1. ArrayList 多线程不安全

在多条线程下，对同一个ArrayList执行add方法时，可能会报java.util.ConcurrentModificationException，即为并发修改时错误。解决方法有3种：

  1. List list = new Vector<>();
  2. List list = Collections.synchronizedList(new ArrayList<>());
  3. List list = new CopyOnWriteArrayList<>();
面试问题：使用CopyOnWriteArrayList，不使用Vector的原因？

Vector 使用的是 synchronizeid 效率比较低
CopyOnWriteArrayList 使用的是 lock锁 效率比较高

package com.mango.unsafe;

import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;

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

        List<Object> list = Collections.synchronizedList(new ArrayList<>());
        for(int i = 0;i < 100;i++){
            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(list);
            },String.valueOf(i)).start();
        }
    }
}

2. Set 多线程不安全

在多条线程下，对同一个HashSet执行add方法时，可能会报java.util.ConcurrentModificationException，即为并发修改时错误。解决方法有2种：

  1. Set< String > set = Collections.synchronizedSet(new HashSet<>());
  2. Set< String > set = new CopyOnWriteArraySet<>();
package com.mango.unsafe;

import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.CopyOnWriteArraySet;

public class Test2 {
    public static void main(String[] args) {
//        HashSet<String> set = new HashSet<>();
//        Set<String> set = Collections.synchronizedSet(new HashSet<>());
        Set<String> set = new CopyOnWriteArraySet<>();
        for (int i = 0; i < 10 ; i++){
            new Thread(()->{
                set.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(set);
            },String.valueOf(i)).start();
        }
    }
}

3. 关于Map

在这里插入图片描述
在多条线程下，对同一个HashMap执行put方法时，可能会报java.util.ConcurrentModificationException，即为并发修改时错误。解决方法有2种：

  1. Set< String > set = Map<Object, Object> map = Collections.synchronizedMap(new HashMap<>());
  2. Set< String > set = new ConcurrentHashMap<>();
package com.mango.unsafe;

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;

public class Test3 {
    public static void main(String[] args) {
        // map 是这样的嘛？不是，工作中不用HashMap
        // 默认等价于什么？ new HashMap<>(16,0.75);

        Map<Object, Object> map = new ConcurrentHashMap<>();
//        Map<Object, Object> map = Collections.synchronizedMap(new HashMap<>());
        // 加载因子，初始化容量
        for (int i = 0; i < 30; i++) {
            new Thread(()->{
                map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0,5));
                System.out.println(map);
            },String.valueOf(i)).start();
        }
    }
}

4. 关于Callable

  1. 可以有返回值。
  2. 可以抛出异常。
  3. 方法不同。run() / call()
package com.mango.callable;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<String> stringFutureTask = new FutureTask<String>(new MyThread());
        new Thread(stringFutureTask,"A").start(); // 怎么启动callable
        String s = stringFutureTask.get();
        System.out.println(s);
    }
}
class MyThread implements Callable<String>{
    @Override
    public String call() throws Exception {
        System.out.println("call()");
        return "1024";
    }
}

new Thread无法直接执行Callable 所以需要一个Runnable的父级FutureTask，作为一个适配器，这个类需要一个Callable实现类作为参数。

5. 常用的辅助类

5.1 CountDownLatch

countDownLatch.countDown(); 计数器 -1。
countDownLatch.await(); 等待计数器归零，然后向下执行。

每次有线程调用countDown()数量-1，假设计数器变为0，countDownLatch.await();就会被唤醒。

public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        // 倒计时 总数是6
        CountDownLatch countDownLatch = new CountDownLatch(6);
        for (int i = 0; i < 6; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"GO OUT");
                countDownLatch.countDown(); // 数量-1
            },String.valueOf(i)).start();
        }
        countDownLatch.await(); // 等待计数器归零，然后再向下执行
        System.out.println(1);
    }
}

5.2 CyclicBarrier

加法计数器

public class CyclicBarrierDemo {
    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7,()->{
            System.out.println("召唤神龙成功");
        });
        for (int i = 1; i <= 7; i++) {
            final int temp = i;
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"收集第"+temp+"个龙珠");
                try {
                    cyclicBarrier.await(); // 等待
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

5.3 Semaphore

semaphore.acquire(); 获得，假设已经满了，等待，等到被释放为止！
semaphore.release(); 释放，会将当前的信号量+1，然后唤醒等待线程！

作用：多个共享资源互斥的作用！并发限流，控制最大的线程数量！


public class SemaphoreDemo {
    public static void main(String[] args) {
        // 线程数量：停车位！限流
        Semaphore semaphore = new Semaphore(3);

        for (int i = 0; i < 6; i++) {
            new Thread(()->{
                // semaphore.acquire();
                try {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName()+"抢到车位");
                    TimeUnit.SECONDS.sleep(2);
                    System.out.println(Thread.currentThread().getName()+"离开车位");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    semaphore.release();
                }

                // semaphore.release(); 释放
            },String.valueOf(i)).start();
        }
    }
}

6. ReentrantReadWriteLock

独占锁（写锁）：一次只能被一个线程占有
共享锁（读锁）：多个线程可以同时占有
读-读 可以共存！
读-写 不能共存！
写-写 不能共存！
ReentrantReadWriteLock 可以使写的时候只能一条线程写，读的时候一起读，如果使用lock，读的时候也只能一个一个线程读。

package com.mango.rw;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class Test {
    public static void main(String[] args) {
        MyCache2 myCache = new MyCache2();

        // 写入
        for (int i = 0; i < 5; i++) {
            final int temp = i;
            new Thread(()->{
                myCache.put(temp+"",temp+"");
            },String.valueOf(i)).start();
        }
        // 读取
        for (int i = 0; i < 5; i++) {
            final int temp = i;
            new Thread(()->{
                myCache.get(temp+"");
            },String.valueOf(i)).start();
        }
    }
}

// 自定义缓存

class MyCache{
    private volatile Map<String,Object> map = new HashMap<>();

    // 存，写
    public void put(String key,Object value){
        System.out.println(Thread.currentThread().getName()+"写入"+key);
        map.put(key,value);
        System.out.println(Thread.currentThread().getName()+"结束");
    }

    // 取，读
    public void get(String key){
        System.out.println(Thread.currentThread().getName()+"读取"+key);
        Object o = map.get(key);
        System.out.println(Thread.currentThread().getName()+"读取结束");
    }
}

// 加锁
class MyCache2{
    private volatile Map<String,Object> map = new HashMap<>();

    // 读写锁：更加细粒度的控制
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

    // 存，写，写入的时候，只希望同时只有一个线程写
    public void put(String key,Object value){
        lock.writeLock().lock();
        System.out.println(Thread.currentThread().getName()+"写入"+key);
        map.put(key,value);
        System.out.println(Thread.currentThread().getName()+"结束");
        lock.writeLock().unlock();
    }

    // 取，读，所有人都可以读
    public void get(String key){
        lock.readLock().lock();

        System.out.println(Thread.currentThread().getName()+"读取"+key);
        Object o = map.get(key);
        System.out.println(Thread.currentThread().getName()+"读取结束");
        lock.readLock().unlock();
    }
}

7. 阻塞队列

7.1 阻塞

写入：如果队列满了，就必须阻塞等待。

7.2 队列

取：如果队列是用空，必须阻塞等待生产。

7.3 阻塞队列

是Collection的子类，和List、Set同级。
BlockingQueue不是新的东西。
在这里插入图片描述
什么情况下我们会使用阻塞队列：多线程并发处理、线程池！
在这里插入图片描述

7.4 四组API

（1）ArrayBlockingQueue

方式抛出异常有返回值，不抛出异常阻塞等待超时等待
添加addofferputoffer( , , )
移除removepolltakepoll( , )
判断队首元素elementpeek--

两种队列异常：IllegalStateException和NoSuchElementException

（2）SynchronousQueue

SynchronousQueue 是同步队列，和其他的BlockingQueue不一样，SynchronousQueue 不存储元素，put了一个元素，必须从里面先take取出来。

public class Test02 {
    public static void main(String[] args) {
        SynchronousQueue<String> blockingQueue = new SynchronousQueue<>(); // 同步队列

        new Thread(()->{
            try {
                System.out.println(Thread.currentThread().getName()+"put 1");
                blockingQueue.put("1");
                System.out.println(Thread.currentThread().getName()+"put 2");
                blockingQueue.put("2");
                System.out.println(Thread.currentThread().getName()+"put 3");
                blockingQueue.put("3");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"t1").start();

        new Thread(()->{
            try {
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName() + "=>" + blockingQueue.take());
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName() + "=>" + blockingQueue.take());
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName() + "=>" + blockingQueue.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"t2").start();
    }
}

8. 线程池（重点）

三大方法、7大参数、4种拒绝策略

池化奇数

程序的运行，本质：占用系统资源！优化资源的使用！=》池化奇数

线程池、连接池（JDBC）、内存池、对象池…创建、销毁。十分浪费资源

池化技术：实现准备好一些资源，有人要用，就来我这里拿，用完之后还给我，下个人再来用。

好处：

  • 降低资源消耗。
  • 提高响应的速度。
  • 方便管理。

线程复用、可以控制最大并发数、管理线程

8.1 三大方法

Executors 工具类中的三大方法。
在这里插入图片描述

（1）Executors.newSingleThreadExecutor();

单个线程。

// 使用线程池之后，使用线程池创建
public class Test1 {
    public static void main(String[] args) {
        ExecutorService threadPool = Executors.newSingleThreadExecutor();
//        Executors.newFixedThreadPool(5);
//        Executors.newCachedThreadPool();

       try{
           for (int i = 0; i < 10; i++) {
               threadPool.execute(()->{
                   System.out.println(Thread.currentThread().getName()+"ok");
               });
           }
       }catch(Exception ee) {
           ee.printStackTrace();
       }finally {
           threadPool.shutdown();
       }

        // 线程池用完要关闭
    }
}

（2）Executors.newFixedThreadPool(5);

创建一个固定的线程池大小。

// 使用线程池之后，使用线程池创建
public class Test1 {
    public static void main(String[] args) {
//        ExecutorService threadPool = Executors.newSingleThreadExecutor();
        ExecutorService threadPool = Executors.newFixedThreadPool(5);
//        Executors.newCachedThreadPool();

       try{
           for (int i = 0; i < 10; i++) {
               threadPool.execute(()->{
                   System.out.println(Thread.currentThread().getName()+"ok");
               });
           }
       }catch(Exception ee) {
           ee.printStackTrace();
       }finally {
           threadPool.shutdown();
       }

        // 线程池用完要关闭
    }
}

（3） Executors.newCachedThreadPool();

可伸缩的，遇强则强，遇弱则弱。

// 使用线程池之后，使用线程池创建
public class Test1 {
    public static void main(String[] args) {
//        ExecutorService threadPool = Executors.newSingleThreadExecutor();
//        ExecutorService threadPool = Executors.newFixedThreadPool(5);
        ExecutorService threadPool = Executors.newCachedThreadPool();

       try{
           for (int i = 0; i < 10; i++) {
               threadPool.execute(()->{
                   System.out.println(Thread.currentThread().getName()+"ok");
               });
           }
       }catch(Exception ee) {
           ee.printStackTrace();
       }finally {
           threadPool.shutdown();
       }
        // 线程池用完要关闭
    }
}

8.2 七大参数

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
本质：ThreadPoolExecutor （）；

 public ThreadPoolExecutor(int corePoolSize, // 核心线程池大小
                              int maximumPoolSize, // 最大线程池大小
                              long keepAliveTime,  // 超时了没有人调用，自动释放
                              TimeUnit unit,  // 超时单位
                              BlockingQueue<Runnable> workQueue, // 阻塞队列
                              ThreadFactory threadFactory, // 线程工厂：创建线程，一般不用动
                              RejectedExecutionHandler handler) { // 拒绝策略
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

8.3 四种拒绝策略

在这里插入图片描述

（1） new ThreadPoolExecutor.AbortPolicy()

银行满了 候客区也满了 还有人进来 不处理这个人的，抛出异常 RejectedExecutionException

会报错

 
// 使用线程池之后，使用线程池创建
public class Test1 {
    public static void main(String[] args) {
        // 自定义线程池！
        ExecutorService threadPool = new ThreadPoolExecutor(
                2,
                5,
                3,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy() 
                );

       try{
           for (int i = 1; i <= 10; i++) {
               threadPool.execute(()->{
                   System.out.println(Thread.currentThread().getName()+"ok");
               });
           }
       }catch(Exception ee) {
           ee.printStackTrace();
       }finally {
           threadPool.shutdown();
       }

        // 线程池用完要关闭
    }
}

（2） new ThreadPoolExecutor.CallerRunsPolicy()

哪来的去哪里

假如线程池超过了最大值（阻塞队列+最大线程池的值），会回到main方法调用。

不会报错

public class Test1 {
    public static void main(String[] args) {
        // 自定义线程池！
        ExecutorService threadPool = new ThreadPoolExecutor(
                2,
                5,
                3,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.CallerRunsPolicy()  // 哪里来的去哪里
                );

       try{
           for (int i = 1; i <= 10; i++) {
               threadPool.execute(()->{
                   System.out.println(Thread.currentThread().getName()+"ok");
               });
           }
       }catch(Exception ee) {
           ee.printStackTrace();
       }finally {
           threadPool.shutdown();
       }

        // 线程池用完要关闭
    }
}

（3） new ThreadPoolExecutor.DiscardPolicy()

队列满了不继续执行任务

假如线程池超过了最大值（阻塞队列+最大线程池的值），会回到main方法调用。

不会报错

public class Test1 {
    public static void main(String[] args) {
        // 自定义线程池！
        ExecutorService threadPool = new ThreadPoolExecutor(
                2,
                5,
                3,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.DiscardPolicy()  // 队列满了
                );

       try{
           for (int i = 1; i <= 10; i++) {
               threadPool.execute(()->{
                   System.out.println(Thread.currentThread().getName()+"ok");
               });
           }
       }catch(Exception ee) {
           ee.printStackTrace();
       }finally {
           threadPool.shutdown();
       }

        // 线程池用完要关闭
    }
}

（4） new ThreadPoolExecutor.DiscardOldestPolicy()

队列满了尝试去和最早竞争

假如线程池超过了最大值（阻塞队列+最大线程池的值），会回到main方法调用。

不会报错

public class Test1 {
    public static void main(String[] args) {
        // 自定义线程池！
        ExecutorService threadPool = new ThreadPoolExecutor(
                2,
                5,
                3,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.DiscardOldestPolicy()  // 队列满了
                );

       try{
           for (int i = 1; i <= 10; i++) {
               threadPool.execute(()->{
                   System.out.println(Thread.currentThread().getName()+"ok");
               });
           }
       }catch(Exception ee) {
           ee.printStackTrace();
       }finally {
           threadPool.shutdown();
       }

        // 线程池用完要关闭
    }
}

9. 小结

最大线程该如何定义？

9.1 CPU 密集型

几核就是几，可以保持CPU的效率最高！
获取CPU的方法Runtime.getRuntime().availableProcessors()

9.2 IO 密集型

判断你程序中十分耗IO的线程。
程序 15个大型任务 io十分占用资源！

-Kk
关注
专栏目录
博客
前端知识点（面试可看） —— JS
01-04 1363
马上就要毕业啦，没有参加2023年的秋招，准备在最近开始找全职或者实习工作，然后也马上过年了，总结和理一下自己的知识要点，参加2024年的春招。
博客
前端知识点（面试可看）—— CSS篇
01-03 1020
马上就要毕业啦，没有参加2023年的秋招，准备在最近开始找全职或者实习工作，然后也马上过年了，总结和理一下自己的知识要点，参加2024年的春招。
博客
前端知识点（面试可看） —— HTML
01-03 1545
马上就要毕业啦，没有参加2023年的秋招，准备在最近开始找全职或者实习工作，然后也马上过年了，总结和理一下自己的知识要点，参加2024年的春招。
博客
把Canvas捡起来吧！
01-03 441
canvas是HTML5新增的一种新特性，一种使用JavaScript绘制图形的HTML元素。
博客
Docker 入门 ------容器互通以及Dockerfile
12-30 1692
本章节主要介绍了Docker容器如何进行互通，以及容器互通时需要注意的事项以及细节，然后详细的介绍了Dockerfile各个关键字的含义，以及如何使用，到这里Docker入门的章节就结束了，后面会有一个Docker实战篇。
博客
Docker 入门 ------ 基本命令
12-29 2540
本章主要描述了Docker的基本命令，包括镜像：创建、删除、标签等，并且如何从远程仓库拉取下来，容器的运行如何进入容器等。
博客
Docker入门 ------ 概念和安装
12-28 1352
本章主要讲解了Docker的背景、使用Docker的优势、和虚拟机的差别、核心概念是什么和如何在Centos中如何安装Docker。在下一章中我们将主要学习Docker中的命令。
博客
MEIS —— 前端部分基本配置
09-29 1573
这篇文章我们随着上一篇文章继续往下叙述，主要是将element和windicss等开发配置进项目中，以及基本的一些页面和组件给他完成。
博客
记录一个教学的交互式系统的开发 —— 环境搭建
09-28 1679
最近临近毕业，也到了毕业设计和找工作的时间了，所以就想着做一个开源项目，之前上课也不是很满意学校的教学系统，也就是，想着做一个可以记录学生学习记录和教师教学记录的平台，支持网页、桌面应用和小程序的项目。这个项目呢打算使用的技术栈：前端：vue3.0 + typescript + element plus + electron后端：golang + gin + gorm 项目名：Mango Education Interactive Service —— MEIS技术栈会有出入后面也会持续更新的。
博客
uni-app v-for循环 click无法传参解决方案
04-22 1万+
场景：循环后端数据数据控制子级是否显示<view :class="['inspect-item-wrap', !item.show ? 'collapse': '']" v-for="item in list_arr.attribute_values" :key="item.id"> <view class="item-show-wrap" @click="collapse(item)"> <text class="item-title">{{item.name}
博客
JUC 并发编程学习（4）
12-08 1414
1. JMM请你谈谈对Volatile的理解Volatile是Java虚拟机提供轻量级的同步机制。保证可见性不保证原子性禁止指令重排什么是JMMJVM：Java内存模型，不存在的东西，他是一个概念、约定。关于JMM的一些同步的约定：线程解锁前，必须把共享变量立刻刷回主存。线程枷锁前，必须读取主存中的最新值到工作内存中！加锁和解锁是同一把锁。线程：工作内存、主内存八种操作：内存交互操作　　　内存交互操作有8种，虚拟机实现必须保证每一个操作都是原子的，不可在分
博客
JUC 并发编程学习（3）
12-04 226
1. 四大函数式接口（必须掌握）新时代程序员：lambda表达式、函数式接口、链式编程、Stream流式计算1.1 函数式接口@FunctionalInterfacepublic interface Runnable { /** * When an object implementing interface <code>Runnable</code> is used * to create a thread, starting the threa
博客
JUC 并发编程学习（1）
12-01 150
1. 什么是JUCjava.util 工具包、包、分类业务：普通线程代码 ThreadRunnable 没有返回值、效率相比于Callable相对较低！2. 线程和进程线程、进程，如果不能使用一句话说出来的的基数，不扎实！进程：一个程序，QQ.exe Music.exe 程序的集合 ；一个进程往往可以包含多个线程，至少包含一个！Java默认有两个线程：main线程 和 GC线程。线程： 开了一个进程 Typora，写字，自动保存（线程负责）对于Java而言：Thread、Run
博客
Java 注解和反射
11-20 135
1. 注解（Annotation）一、作用可以被其他程序(比如：编译器等)读写不是程序本身，可以对程序做出解释。（这一点和注释没有区别）二、格式注解是以“@注释名”在代码中存在的，还可以添加一些参数值，例如：@SuppressWarnings(value="unchecked).三、例子public class Demo01 extends Object{ // @Override 重写的注解 @Override public String toString(
博客
Java 多线程学习（线程池和总结）
11-19 109
1. 线程池1.1 背景经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。1.2 思路提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的交通工具。1.3 好处提高响应速度（减少了创建新线程的时间）降低资源消耗（重复利用线程池中线程，不需要每次都创建）便于线程管理corePoolSize：核心池的大小maximumPoolSize：最大线程数keepAliveTime：线程没有任务时最多保持多长
博客
Java 多线程学习（线程通信——消费者和生产者）
11-19 236
线程通信假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中的产品取走消费。如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，知道仓库中的产品被消费者取走为止。如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费并等待，知道仓库中再次放入产品为止。这是一个线程同步问题，生产者和消费者共享一个资源，并且生产者和消费者之间相互依赖，互为条件在生产者消费者问题中，仅有synchronized是不够的synchronized 可阻止并发更新同一个共享资
博客
Java 多线程学习（Lock锁）
11-19 132
Lock锁从JDK5.0开始，Java提供了更强大的线程同步机制——通过显示定义同步锁对象来实现同步。同步锁使用Lock对象充当。java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。ReentrantLock类实现了Lock，他拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是Reentran
博客
Java 多线程（死锁）
11-19 112
死锁多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形，某一个同步块同时拥有两个以上对象的锁时，就可能会发生“死锁”的问题。死锁可能发生的情况：package com.mango.deadlock;// 死锁：多个线程互相抱着对方需要的资源，然后形成僵持。public class DealLock { public static void main(String[] args) { Make
博客
Java 三种不安全线程及解决方案
11-19 244
1. 三种不安全线程1.1 List 集合package com.mango.syn;import java.util.ArrayList;import java.util.List;// 线程不安全的集合public class UnsafeList { public static void main(String[] args) { List<String> list = new ArrayList<>(); for (
博客
Java 线程同步
11-18 106
Java 线程同步处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象。这时候我们就需要线程同步。线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用。由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加入synchronized 锁机制，当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可。存在以下问题：一
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值