Java并发编程概述

最新推荐文章于 2022-04-22 07:33:17 发布
最新推荐文章于 2022-04-22 07:33:17 发布
阅读量193 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37208669/article/details/108035949
版权

基本概念

多线程业务场景

  • 异步任务

1、用户注册后的异步通知，短信/邮箱

2、异步记录日志

  • 定时任务

定期备份日志、数据库

  • 分布式计算

分片计算/Hadoop的map-reduce

  • 服务器编程

Servlet编程模型

进程、线程、协程

  • 基本概念

进程: 本质上是一个独立执行的程序，进程是操作系统进行资源分配和调度的基本概念，操作系统进行行资源分配和调度的一个独立单位

线程:是操作系统能够进⾏运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。 ⼀个进程中可以并发多个线程，每条线程执行不同的任务，切换受系统控制。

协程: 又称为微线程，是⼀种⽤户态的轻量级线程，协程不像线程和进程需要进行系统内核上的上下文切换，协程的上下文切换是由⽤户⾃⼰决定的，有自⼰的上下文，所以说是轻量级的线程，也称之为用户级别的线程就叫协程，⼀个线程可以多个协程,线程进程都是同步机制，⽽协程则是异步。 Java的原生语法中并没有实现协程,⽬前python、Lua和GO等语言支持

  • 关系

一个进程可以有多个线程，它允许计算机同时运行两个或多个程序。线程是进程的最⼩执行单 位，CPU的调度切换的是进程和线程，进程和线程多了了之后调度会消耗大量的CPU，CPU上真正运行的是线程，线程可以对应多个协程

  • 协程的优缺点

优点:

非常快速的上下文切换，不⽤系统内核的上下文切换，减⼩开销 单线程即可实现高并发，

单核CPU可以支持上万的协程 由于只有⼀个线程，也不存在同时写变量的冲突，在协程中控制共享资源不需要加锁

缺点:

协程⽆法利⽤多核资源，本质也是个单线程

协程需要和进程配合才能运行在多CPU上 ⽬前java没成熟的第三方库，存在⻛险 调试debug存在难度，不利于发现问题

并发与并行

  • 并发

本质上只是通过cpu的切换，交替的执行任务。

但是由于切换速度过快，导致看上去是多个任务一起在执行一样

  • 并行

真正的多任务执行

Java实现多线程的若干种方式

案例：多线程输出字符串

  • 继承Thread类
@Slf4j
public class HelloThread extends Thread {
    @Override
    public void run() {
        log.info("😬 我的线程号：{}", Thread.currentThread().getName());
    }
}

调用

        HelloThread thread = new HelloThread();
        HelloThread thread1 = new HelloThread();
        thread.start();
        thread1.start();
  • 实现Runnable接口
@Slf4j
public class HelloThread implements Runnable {
    @Override
    public void run() {
        log.info("😬 我的线程号：{}", Thread.currentThread().getName());
    }
}

调用

        HelloThread thread = new HelloThread();

        Thread thread1 = new Thread(thread);
        Thread thread2 = new Thread(thread);

        thread1.start();
        thread2.start();
  • Stream（JDK8+）
        List<String> jobList = new ArrayList<>();
        jobList.add("job1");
        jobList.add("job2");
        jobList.add("job3");

        jobList.parallelStream()
                .forEach(item -> {
                    System.out.println("当前线程号：" + Thread.currentThread().getName() + "\t\t" + item);
                });

输出结构如下

当前线程号：main		job2
当前线程号：ForkJoinPool.commonPool-worker-1		job1
当前线程号：ForkJoinPool.commonPool-worker-2		job3
  • Callable和FutureTask方式

JDK1.5+支持

public class MyTaskTest {


    public static void main(String[] args) {
        FutureTask<Object> futureTask = new FutureTask<>(() -> {
            System.out.println("通过Callable实现多线程：" + Thread.currentThread().getName());
            return "返回值1：" + Thread.currentThread().getName();
        });
        FutureTask<Object> futureTask2 = new FutureTask<>(() -> {
            System.out.println("通过Callable实现多线程：" + Thread.currentThread().getName());
            return "返回值2：" + Thread.currentThread().getName();
        });
        Thread thread = new Thread(futureTask);
        Thread thread2 = new Thread(futureTask2);
        thread.start();
        thread2.start();
        try {
            System.out.println(futureTask.get());
            System.out.println(futureTask2.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}
  • 线程池的方式
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 10; i++) {
            executorService.execute(()->{
                System.out.println("当前线程号："+Thread.currentThread().getName());
            });
        }
        executorService.shutdown();//线程池中的活跃线程处理完任务后，会自动关闭线程池

多任务并发执行实用代码

package com.zhangln.shanhaijing.thread;

import lombok.extern.slf4j.Slf4j;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.*;

@Slf4j
public class Demo01CompleteFutureMain {
    public static void main(String[] args) throws InterruptedException {
//        任务列表
        List<Integer> jobList = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14);
        int nThreads = 3;
//        工作线程池
        ExecutorService executorService = new ThreadPoolExecutor(nThreads, nThreads,
                0L, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<>());
//        接收每个任务的执行结果
        List<CompletableFuture<String>> completableFutures = new ArrayList<>(jobList.size());

//        任务分派
        for (int i = 0; i < jobList.size(); i++) {

            try {
                Integer jobId = jobList.get(i);

                CompletableFuture<String> integerCompletableFuture = CompletableFuture.supplyAsync(() -> {

                    log.info("模拟任务执行，执行任务：{},线程号：{}", jobId, Thread.currentThread().getName());
//                    睡几秒
                    return jobId + "任务执行结果"+Thread.currentThread().getName();
                }, executorService);
//            保存本次任务执行结果
                completableFutures.add(integerCompletableFuture);
            } catch (Exception e) {
                log.error(e.getMessage(), e);
            }

        }

        log.info("任务分派结束");

//        等待全部任务执行完毕
        CompletableFuture[] completableFutures1 = new CompletableFuture[completableFutures.size()];
        CompletableFuture<Void> voidCompletableFuture =
                CompletableFuture.allOf(completableFutures.toArray(completableFutures1));
        try {
            voidCompletableFuture.get();
            log.info("打印执行结果");
            completableFutures.stream()
                    .forEach(tmp -> {
                        try {
                            log.info("执行结果：{}", tmp.get());
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    });
        } catch (Exception e) {
            e.printStackTrace();
        }

        executorService.shutdown();
        log.info("任务执行完毕");

        TimeUnit.SECONDS.sleep(2);

    }
}

线程状态

JDK的线程状态有6种，JVM里面有9种。

一般我们说的线程状态是JDK的线程状态

常见状态

  • 新建 new：生成线程对象，未调用该对象的start方法，如 new Thread()
  • 就绪 runnable：新建的对象调用start方法后，线程处于就绪状态

就绪状态的来源不仅仅是new的对象调用start方法。还可以来自运行装和阻塞状态。

所谓就绪，就是说我已经准备好了，只要CPU有空了，就可以调度我进行线程执行。

  • 运行 running：获取到cpu使用权的线程，就是处于running状态

注意：在jdk中，是没有running状态的，见 Thread类的State内部枚举类。

它把runnable和running两种状态合并了

  • 阻塞 blocked

    • 等待阻塞

    进入该状态的线程需要等待其他线程做出一定动作，如 通知、中断。此状态CPU不进行分配。

    可能需要被唤醒，也可能无限等待下去。

    • 同步阻塞：线程执行需要的资源被锁住，此时就处于同步阻塞状态

  • 终止 terminate

    线程的run执行完毕

  • 线程常见API

    • sleep

      线程方法，交出CPU使用权；等待预计时间后再恢复；进行阻塞状态（TIME_WAITING）；睡眠结束变为就绪状态

    • yield

      线程方法，暂停当前线程，让CPU执行其他线程

      注意：yield操作不会让线程处于阻塞状态，而是变为就绪。只需要重新获得CPU使用权就会回到运行状态

    • join

      线程方法

      在主线程调用该方法，会让主线程休眠，不会释放已经持有的对象锁。

      让调用join方法的线程先执行，再执行其他线程

    • wait

      对象方法，释放对象的锁，进入线程的等待队列。

      需要靠notify/notifyAll唤醒。或者wait（timeout后自动唤醒）

      sleep和wait的区别就在于是否释放锁

    • notify

      对象方法；唤醒对象监视器上等待的单个线程（随机抽取一个）

    • notifyAll

      对象方法，唤醒对象监视器上等待的所有线程

线程状态切换

CCNE87

Java中保证线程安全的方式

  • 加锁

synchronize/ReentrantLock

  • 线程安全类

CopyOnWriteArrayList/ConcurrentHashMap

  • ThreadLocal

volatile关键字

了解volatile关键字不?能否解释下，然后这和synchronized有什么大的区别

答：

volatile是轻量级的synchronized，保证了共享变量的可见性，被volatile关键字修饰的变量，如果值发生了变化，其他线程⽴立刻可见，避免出现脏读现象

volatile:保证可见性，但是不能保证原子性 synchronized:保证可见性，也保证原子性

使用场景

1、不能修饰写入操作依赖当前值的变量，⽐如num++、num=num+1,不是原⼦操作，肉眼看起来是，但是JVM字节码层⾯不⽌一步

2、由于禁止了指令重排，所以JVM相关的优化没了，效率会偏弱

什么是指令重排？

指令重排分为编译器重排和运行期重排

JVM在编译java代码，或者cpu在执行jvm字节码的是，在不改变执行结果的情况下对指令执行顺序进行调整，以优化执行效率。

  • 为什么会出现脏读

JAVA内存模型简称 JMM ；

JMM规定所有的变量存在主内存，每个线程有⾃己的工作内存,线程对变量的操作都在工作内存中进行，

不能直接对主内存进行操作

使用volatile修饰变量 每次读取前必须从主内存属性最新的值 每次写入需要立刻写到主内存中

volatile关键字修饰的变量随时看到的自己的最新值，假如线程1对变量v进⾏行修改，那么线程2 是可以马上看⻅

7A4C7329-5D58-43FF-BF7B-452627FCBEB4.png

  • 什么是happens-before

因为jvm会对代码进行编译优化，指令会出现重排序的情况，为了避免编译优化对并发编程安全性的影响，需要happens-before规则定义一些禁止编译优化的场景，保证并发编程的正确性。

https://www.jianshu.com/p/9464bf340234

并发编程三要素

  • 原子性：即一些操作，要么全部成功，要么全部失败。执行期间不能被打断。类似于数据库的事务的概念
  • 有序性：程序的执行顺序按照代码的先后顺序执行（因为处理器有可能通过指令重排进行重新排序）
  • 可见性：线程A、B之间，A对共享变量的写操作，B能够马上看到

以上三特性，是并发编程中需要保证的

进程/线程调度策略

先来先服务

短作业优先

高响应比优先

时间片轮询

优先级调度

常用锁

悲观锁

当线程去操作数据的时候，总认为别的线程会去修改数据。

所以每次拿数据的时候，都会上锁。别的线程去拿数据的时候就会阻塞。

如：synchronized

乐观锁

每次去拿数据的时候都认为别人不会修改，更新的时候判断别人是否会去更新数据，通过数据版本号进行控制

如果数据被更改了，就拒绝更新。如 CAS是乐观锁，但是，严格意义来说，并不是锁。

公平锁

多个线程按照申请锁的顺序来获取锁。

简单来说，如果一个线程组中，能够保证每个线程都能拿到锁，比如：ReentranLock（底层是同步队列）

悲观锁适合写操作多的场景

乐观锁适合读操作多的场景

非公平锁

获取锁的方式是随机的，保证不了每个线程都能拿到锁。

会存在有的线程一直拿不到锁的情况。如：synchronized、ReentrantLock

ReentrantLock公平与否，由构造函数控制

可重入锁

也叫递归锁。

在外层使用锁之后，内层仍然可以使用，并且不发生死锁。

即：在调用方法A的时候，获取了锁，方法A在执行过程中，调用了方法B，在B中继续获取该锁。在可重入锁中，这种操作是被允许的。

可重入锁在一定程度上避免了死锁。

不可重入锁

若当前线程执行某个方法已经获取了该锁，那么在方法中尝试再次获取锁时，就会获取不到被阻塞。

自旋锁

一个线程在获取锁的时候，如果锁已经被其他线程获取，那么该线程将循环等待。

然后不断判断锁是否能够被成功获取，直到获取到锁才会退出循环。

任何时刻最多只有一个执行单元获取到锁

不会发生线程状态的切换，一直处于用户态；减少了线程的上下文切换，但同时也消耗了CPU

其他

  • 共享锁

这种锁添加后，多线程可以读，但无法写。

该锁可被多个线程持有，用于资源数据共享

  • 互斥锁

该锁只能被一个线程持有。

加锁后其他线程试图获取此锁，都会阻塞，知道当前线程解锁

  • 死锁

两个或两个以上的线程在执行过程中，由于资源竞争，导致阻塞

  • 偏向锁–>轻量级锁–>重量级锁

这三种锁，是JVM为了提高锁的获取和释放效率而做的优化。

针对synchronized的锁升级。锁的状态通过对象监视器在对象头中的字段来表名，是不可逆的过程。

  • 分段锁/行锁/表锁

死锁案例与解决

写一个死锁，并解决

  • 死锁的引发
import java.util.concurrent.TimeUnit;

public class DeadLockDemo {
    //这两个对象就代表锁
    private static String locka = "locala";
    private static String lockb = "localb";

    public void methodA() {
        //以同步代码块的方式使用锁
        synchronized (locka) {
            System.out.println("我是A方法，获取锁A" + Thread.currentThread().getName());
            try {
//                让出CPU执行权，不释放锁
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            synchronized (lockb) {
                System.out.println("我是A方法，获取锁B" + Thread.currentThread().getName());
            }
        }
    }

    public void methodB() {
        synchronized (lockb) {
            System.out.println("我是B方法，获取锁B" + Thread.currentThread().getName());
            try {
//                让出CPU执行权，不释放锁
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            synchronized (locka) {
                System.out.println("我是B方法，获取锁A" + Thread.currentThread().getName());
            }
        }
    }

    public static void main(String[] args) {
        DeadLockDemo deadLockDemo = new DeadLockDemo();
        new Thread(() -> {
            deadLockDemo.methodA();
        }).start();

        new Thread(() -> {
            deadLockDemo.methodB();
        }).start();

        System.out.println("我是主线程：" + Thread.currentThread().getName());
    }
}

1、线程1拿到锁a

2、线程1睡眠

3、线程2拿到锁b

4、线程2睡眠

5、线程1要拿锁b，线程2要拿锁a，但两把锁都未释放，就堵死了

以上，我们总结发生死锁的4个必要条件

1、互斥条件：资源不能共享， 只能由一个线程使用

2、请求与保持条件：线程已经获得一些资源，但因请求其他资源发生阻塞，对已经获得的资源保持不释放

3、不可抢占：有些资源不可抢占，当某个线程获得资源后，系统不能强行回收，只能由线程自己用完释放

4、循环等待条件：多个线程下形成环形链，每个都占用了对方申请的下个资源

以上条件，只要有一个不成立，就不会发生死锁

  • 解决死锁问题

常见方法

1、调整申请锁的范围

对于上述的案例中，只需要将锁的范围调整为

    public void methodA() {
        synchronized (locka) {
            System.out.println("我是A方法，获取锁A" + Thread.currentThread().getName());
            try {
//                让出CPU执行权，不释放锁
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        synchronized (lockb) {
            System.out.println("我是A方法，获取锁B" + Thread.currentThread().getName());
        }
    }

就不会发生死锁

锁的范围越小越好。

如无必要，尽量不要让代码在锁中

调整申请锁的顺序

不可重入锁的设计

  • 什么是不可重入锁？

当前线程执行某个方法的时候获取到了锁A，在锁A释放前，如果在方法中再次尝试获取锁A，此时会获取不到被阻塞。

这就是不可重入锁

package com.zhangln.shanhaijing.thread;

/**
 * 不可重入锁
 *
 * @author sherry
 * @description
 * @date Create in 2020/8/10
 * @modified By:
 */

public class UnreentrantLock {

    private boolean isLocked = false;


    public synchronized void lock() throws InterruptedException {
        System.out.println("进入lock加锁" + Thread.currentThread().getName());
        while (isLocked) {
            System.out.println("进入wait等待：" + Thread.currentThread().getName());
            wait();
        }
        isLocked = true;
    }

    public synchronized void unlock() {
        System.out.println("进入unlock解锁" + Thread.currentThread().getName());
        isLocked = false;
//        唤醒当前对象锁等待队列中的某个线程
        notify();
    }
}
  • 使用
    private UnreentrantLock unreentrantLock = new UnreentrantLock();

    @Test
    public void test3() {
        try {
            unreentrantLock.lock();
            System.out.println("1 获取锁");
            unreentrantLock.lock();
            System.out.println("2 获取锁");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            unreentrantLock.unlock();
        }
    }

可重入锁设计

  • 什么是可重入锁

在外层获取到锁后，内层可以继续获取锁

package com.zhangln.shanhaijing.thread;

/**
 * @author sherry
 * @description
 * @date Create in 2020/8/12
 * @modified By:
 */

public class ReentrantLockDemo {
    private boolean isLocked = false;
    //    用于记录是不是重入的线程
    private Thread lockOwner = null;
    //    累计加锁次数
    private int lockedCount = 0;

    public synchronized void lock() throws InterruptedException {
        System.out.println("进入lock加锁" + Thread.currentThread().getName());
        Thread thread = Thread.currentThread();
//        判断是否是同一个线程获取锁
        while (isLocked && lockOwner != thread) {
            System.out.println("进入wait等待：" + Thread.currentThread().getName());
            System.out.println("当前锁状态：" + isLocked);
            System.out.println("当前加锁次数：" + lockedCount);
            wait();
        }
        isLocked = true;
        lockOwner = thread;
        lockedCount++;
    }

    public synchronized void unlock() {
        System.out.println("进入unlock解锁" + Thread.currentThread().getName());
        Thread thread = Thread.currentThread();
//        自己加的锁只有自己才能解
        if (thread == lockOwner) {
            lockedCount--;
            if (lockedCount == 0) {
                lockOwner = null;
                isLocked = false;
//        唤醒当前对象锁等待队列中的某个线程
                notify();
            }

        }

    }

}
  • 测试调用
    @Test
    public void test5() {
        try {
            reentrantLockDemo.lock();
            reentrantLockDemo.lock();

        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            reentrantLockDemo.unlock();
        }
    }

Synchronized深入理解

  • 基本理解

rJExMM

  • jdk6以后的优化

8SErII

jqXDZ9

CAS

  • 概念

Compare And Swap，即 比较再交换

是实现并发技术的一种

底层通过Unsafe类实现原子性操作，操作包含三个数：内存地址（V）、预期原值（A）和新值（B）。

如果内存位置的值与预期原值相匹配，那么处理器会自动将该位置值更新为新值，如果在第一轮循环中，a线程获取地址里面的值被b线程修改了，那么a线程需要自旋，到下次循环才有可能执行。

整个CAS的过程，就是一个乐观锁的过程

AtomicXXX等原子类，底层就是CAS实现的。一定程度上比synchronized性能好，因为synchronized是悲观锁。

注意：线程多的时候，由于CAS自旋，性能反而不好

  • ABA问题

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KGUgU1DC-1597558446071)(http://tuchuang.zhangln.com/s31CQC.png)]

AQS

  • 基本概念

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9eLYLOV8-1597558446072)(http://tuchuang.zhangln.com/nyfooX.png)]

AQS的全称为(AbstractQueuedSynchronizer)，这个类在java.util.concurrent.locks 包下面。它是一个Java提高的底层同步工具类，比如CountDownLatch、ReentrantLock， Semaphore，ReentrantReadWriteLock，SynchronousQueue，FutureTask等皆是基于 AQS的

只要搞懂了了AQS，那么J.U.C中绝大部分的api都能轻松掌握

简单来说:是用一个int类型的变量表示同步状态，并提供了一系列的CAS操作来管理这个同步状态 对象
一个是 state(⽤于计数器，类似gc的回收计数器)
一个是线程标记(当前线程是谁加锁的)

一个是阻塞队列(用于存放其他未拿到锁的线程)

解析ReentranLock

  • 通过参数控制ReentranLock是公平锁还是非公平锁，默认是非公平锁
  • 内部重写了AQS，自定义了锁

ReentranLock与synchronized差别

  • 两者都是独占锁
  • synchronized是悲观锁，会引起其他线程阻塞
  • synchronized无法判断锁状态，可重入、不可中断，非公平锁
  • 加锁过程是隐式的
  • 一般的并发场景足够用了
  • ReentranLock是悲观锁，实现了Lock接口
  • 可判断是否获取到锁，可重入，通过参数控制是否公平锁
  • 需要手动加锁/解锁，解锁操作尽量放在finaly代码块中，保证线程正确释放锁
  • 在复杂并发场景下，确保获取锁的次数与释放锁的次数一致，否则会导致其他线程无法获取锁

读写锁ReentrantReadWriteLock

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-l2TZPBFC-1597558446073)(http://tuchuang.zhangln.com/20200816133132_uaWsk3_325C598A-64DA-421A-A6A9-B940D36F6D13.png)]

  • ReentrantReadWriteLock实现了读写分离锁，适合并发读多的场景
  • 支持公平锁与非公平锁，底层也是AQS的实现
  • 允许从写锁降级为读锁

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cRwSFBJQ-1597558446075)(http://tuchuang.zhangln.com/20200816133614_nbdSmU_0B969139-E2EC-471F-9D18-286621C5D54F.png)]

BlockingQueue

核心：保证生产者不在缓冲区满的时候放入数据，消费者不在缓冲区空时消耗数据

常见的同步方法是采用信号量或加锁机制

4D001781-C09C-43CA-A834-E86BB301DB72.png

6E112931-3397-43C9-9259-7323F924CEAB.png

并发最佳实践

  • 不同模块取不同的线程名称，便于后续问题排查
  • 使用同步代码块或同步方法时，尽量减小同步范围
  • 多比那个发集合少使用同步集合
  • 线程业务需要使用多线程时，优先考虑线程池

C85BD632-B3B9-41CE-9CDD-BD1E4CCDA20E.png

kokoHKM
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java并发编程知识概览
rrq_0324的博客
12-19 358
基础知识 线程池 集合类 锁 JUC辅助工具类 JMM CAS volatile 阻塞队列 ThreadLocal ForkJoin框架
Java并发编程
吴豪杰
09-03 430
线程安全 无状态对象永远是线程安全的 无状态对象指的是没有成员域变量的对象原子操作 自增操作是三个离散操作的简写形式: 获取当前值，加1，写回新值。这是一个 读-改-写 操作的实例，其中，结果的状态衍生自它先前的状态。 竞争条件 当计算的正确性依赖于运行时中的相关的时序或者多线程的交替时，会产生竞争条件；换句话说，想要得到正确的答案，要依赖于“幸运”的时序。最常见的一种竞争条件是 检查再运行
Juc并发编程07——公平锁真的公平吗(源码剖析)
半旧518的博客
04-22 650
先来回顾下公平锁的tryAcquire代码。 protected final boolean tryAcquire(int acquires) { final Thread current = Thread.currentThread(); int c = getState(); if (c == 0) { if (!hasQueuedPredecessors() && //注意这
Java面试题 - 多线程
阿甘兄
05-28 1万+
01 什么是线程？ 线程是操作系统能够进⾏运算调度的最⼩单位，它被包含在进程之中，是进程中的实际运作单位，可以使⽤多线程对进⾏运算提速。 ⽐如，如果⼀个线程完成⼀个任务要100毫秒，那么⽤⼗个线程完成改任务只需10毫秒 02 什么是线程安全和线程不安全？ 线程安全: 就是多线程访问时，采⽤了加锁机制，当⼀个线程访问该类的某个数据时，进⾏保护，其他线程不能进⾏访问，直到该线程读取完，其他线程才可使⽤。不会出现数据不⼀致或者数据污染。 Vector 是⽤同步⽅法来实现线程安全的, ⽽和它相似的ArrayL
深入分析ReentrantLock公平锁和非公平锁的区别
热门推荐
m47838704的专栏
04-20 2万+
在ReentrantLock中包含了公平锁和非公平锁两种锁，通过查看源码可以看到这两种锁都是继承自Sync，而Sync又继承自AbstractQueuedSynchronizer，而AbstractQueuedSynchronizer又继承自AbstractOwnableSynchronizer，下面是类的继承关系图： 其中AbstractOwnableSynchronizer是提供了设置占...
2020-08-13:公平锁和非公平锁有什么区别？
残冬十九
08-14 140
2020-08-13:公平锁和非公平锁有什么区别？前言公平锁和非公平锁有什么区别公平锁非公平锁 前言 每日一题专栏 公平锁和非公平锁有什么区别 公平锁 公平锁：线程按照申请的顺序获取到所，申请的线程进入一个队列去排队，永远都是队里第一位获取到锁。 优点：所有的线程都可以获取到锁资源，不会在队列中拿不到资源 缺点：吞吐量下降，除了队列第一个线程，其他线程会进行阻塞，唤醒阻塞线程开销很大 非公平锁 非公平锁：多个线程去获取锁的时候，会直接去尝试获取，获取不到，再去进入等待队列，如果能获取到，就直接获取到锁。
JAVA并发篇_公平锁与非公平锁
栗筝i的博客
09-14 1940
简单的来说，如果一个线程组里，能保证每个线程都能拿到锁，那么这个锁就是公平锁。相反，如果保证不了每个线程都能拿到锁，也就是存在有线程饿死，那么这个锁就是非公平锁。 一、引入概念 1、公平锁： 多个线程按照申请锁的顺序去获得锁，线程会直接进⼊队列去排队，永远都是队列的第⼀位才能得到锁。 优点：所有的线程都能得到资源，不会饿死在队列中。 缺点：吞吐量会下降很多，队列⾥⾯除了第⼀个线程，其他的线程都会阻塞，cpu唤醒阻塞线程的 开销会很⼤。 2、⾮公平锁： 多个线程去获取锁的时候，会直接去尝试获取，获取不到，.
使用parallelStream进行遍历的坑,以及如何进行避免异步操作中出现的问题
yuhui666666的博客
11-30 911
Java8 已经很久了,现在都已经Java12版本了. 我所在的上家公司,在写代码时候推荐使用lambad来进行操作遍历集合 也就是像下面一样 List<Integer> list = new ArrayList<>(); for (int j = 0; j < 1000; j++) { list.add(j); } list.stream().forEach(value -> { System.out.
Java并发编程简介
Gonelin的博客
12-21 683
并发编程简介 1. 什么是并发编程 所谓并发编程是指在一台处理器上“同时”处理多个任务。并发是在在同一实体上的多个事件。多个事件在同一时间间隔发生。 并发编程 ①从程序设计的角度来讲，是希望通过某些机制让计算机可以在一个时间段内，执行多个任务。 ②从计算机CPU硬件层面来说，是一个或多个物理CPU在多个程序之间多路复用，提高对计算机资源的利用率。 ③从调度算法角度来说，当任务数量多于CPU的核数时，并发编程能够通过系统的任务调度算法，实现多个任务一起执行。 2.并发编程的重要性 它是Java语言中最为晦涩的
说一下公平锁和非公平锁的区别？
u011277123的博客
07-28 734
三太子敖丙2020-03-24 16:26:21 前言 上次我们提到了乐观锁和悲观锁，那我们知道锁的类型还有很多种，我们今天简单聊一下，公平锁和非公平锁两口子，以及他们在我们代码中的实践。 正文 开始聊之前，我先大概说一下他们两者的定义，帮大家回顾或者认识一下。 公平锁：多个线程按照申请锁的顺序去获得锁，线程会直接进入队列去排队，永远都是队列的第一位才能得到锁。 优点：所有的线程都能得到资源，不会饿死在队列中。 缺点：吞吐量会下降很多，队列里面除了第一个线程，其他的线程都会阻塞，cpu唤醒阻.
小滴课堂-学习笔记： 面试必备知识之玩转并发编程技术点
dev666的博客
12-15 233
愿景："让编程不再难学，让技术与生活更加有趣" 更多架构课程请访问 xdclass.net 目录 第1集 多年开发经验的你是否知道线程+进程+协程的区别 第2集 多年开发经验的你是否可以清晰表达 并发、并行的区别 第3集 新版Java多线程的实现方式你知道多少《上》 第4集 新版Java多线程的实现方式你知道多少《下》 第5集 新版Java线程的状态你知道多少？ 第6集 新版Java线程的常见方法你知道多少？ 第7集 新版Java线程的状态转换流程图你会画不 第8集 新版Java并发编.
多线程（synchronized，ReentrantLock，公平锁与非公平锁）
weixin_44962371的博客
09-10 650
1、synchronized synchronized加锁，synchronized 是最常⽤的线程同步⼿段之⼀，CAS是乐观锁的实现， synchronized就是悲观锁了。 1）synchronized锁升级过程 jdk1.6 中为了减少获得锁和释放锁带来的性能消耗⽽引⼊的偏向锁和轻量级锁。 针对 synchronized 获取锁的⽅式，JVM 使⽤了锁升级的优化⽅式，就是先使⽤偏向锁优先同⼀线程然 后再次获取锁，如果失败，就升级为 CAS 轻量级锁，如果失败就会短暂⾃旋，防⽌线程被系统挂起。 最后如果
C语言并发执行的进程怎么写,多进程并发写文件 多进程并发售票 用c语言写
weixin_42143221的博客
05-21 408
tcp多进程并发文件服务器代码？线程是相对独立的执行单位，是计算机系统进行调度的最小单位，其切换由操作系统控制，称之为短作业调度。换句话说您没有任何必要去手动调度线程。如果您想要实现的是连接分配的话，请参考您的操作系统的进程间通信和同步文档。java 多进程并发控制怎么做?python多进程，多线程分别是并行还是并发编写多进程/多线程并发的程序时需要注意哪些方面编写多进程/多线程并发的程序时需要注...
Java读写锁ReadWriteLock
Charge8的博客
06-26 792
一、读写锁ReadWriteLock ReadWriteLock 是 JDK 中的读写锁接口，提供了 readLock 和 writeLock 两种锁的操作机制，一个是读锁，一个是写锁。 ReadWriteLock同Lock一样也是一个接口，ReentrantLock 是Lock的一种实现，ReentrantReadWriteLock 是 ReadWriteLock 的一种实现。 ReadWriteLock 中只有写锁支持Condition，读锁不支持，读锁调用 newCondition() 方法，会
java 什么是并发,java并发编程（一）：并发编程了解
weixin_30975527的博客
03-14 162
采用并发编程的目的是为了使程序运行得更快，但并不是启动更多的线程就能让程序最大限度地并发执行。如果希望通过多线程让程序运行得更快，会有许多要考虑的问题，比如上下文切换、死锁、以及来自硬件和软件支持的限制等。一、上下文切换1、上下文切换的了解上下文切换是指CPU从一个进程或线程切换到另一个进程或线程，CPU通过给每个线程分配CPU时间片来实现这个机制。时间片是CPU分配给各个线程的时间，因为时间片很...
Redis解决雪花算法dataId和workId的自动选择问题
m0_37208669的博客
03-06 9895
文章目录前言算法 1 代码算法 2 代码 前言 雪花算法是分布式系统中常用的唯一 id 生成算法， 一般创建雪花算法的时候，依赖dataCenterId与workerId 这两个值的取值都为 0~31 之间的整型。 对于一个雪花算法的 id 生成器，需要设置这两个参数值。 如果在单实例中，这两个值随便怎么设置都是没问题的， 但是对于应用集群部署的时候，为了保证高可用，肯定需要多实例部署。 这个时候...
Files.walkFileTree遍历文件夹
m0_37208669的博客
12-02 1719
package org.zln.test1; import java.io.File; import java.io.IOException; import java.nio.file.*; import java.nio.file.attribute.BasicFileAttributes; public class Demo1 { public static void main(S...
SpringBoot2.X关闭Security的http认证
m0_37208669的博客
04-11 1559
package com.imooc.config; import org.springframework.context.annotation.Configuration; import org.springframework.security.config.annotation.web.builders.HttpSecurity; import org.springframework.secu...
CompletableFuture执行多线程任务
m0_37208669的博客
04-10 1394
这是一段比较实用的代码段 当我们有很多任务需要多线程执行的时候，就可以使用 @Slf4j public class Demo01CompleteFutureMain { public static void main(String[] args) { // 任务列表 List<Integer> jobList = Arrays.asList(1,...
Java并发编程：并发容器与线程池深度解析
本文将深入探讨Java并发容器和线程池，主要讲解ConcurrentHashMap、ConcurrentLinkedQueue、CopyOnWriteArrayList以及线程池中的ThreadPoolExecutor和ForkJoinPool。同时，还会介绍Future接口的实现，如FutureTask和...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值