java学习02-多线程,线程池,线程锁,线程同步

最新推荐文章于 2024-03-25 20:22:10 发布
最新推荐文章于 2024-03-25 20:22:10 发布
阅读量125 收藏
点赞数
分类专栏： java学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43582343/article/details/118485742
版权

java学习02-多线程,线程池,线程锁,线程同步

定义多线程的3种方式

1. 继承Thread类

继承Thread类,重写run方法,使用 start启动线程

public class MyThread extends Thread {
    @Override
    public void run() {
        //do something
    }

    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
    }
}

使用内部匿名类

Thread myThread = new Thread() {
   @Override
    public void run() {
        super.run();
    }
};
myThread.start();

优点: 简单,直接,一个实例就是一个线程
缺点: 一个类实例只能开启一个线程,不能开启多个线程

MyThread myThread = new MyThread();
myThread.start();
//将抛出异常: java.lang.IllegalThreadStateException
myThread.start();

2. 实现Runnable接口

  1. 线程类实现Runnable接口,重写run()方法
  2. 使用new Thread(Runnable item).start()启动线程
public class MyRunnable implements Runnable {
    @Override
    public void run() {
        //do something
    }
    
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        new Thread(myRunnable).start();
    }
}

使用内部匿名类

Runnable myRunnable = new Runnable(){
     @Override
     public void run() {
         //do something
     }
 };
 new Thread(myRunnable).start();

优点: 可以继承其它类,一个对象实例可以被多个线程公用,线程池只接受Runnable和Callable
缺点: 线程操作相对复杂

//一个Runnable实例可以被多个线程使用
//自然可以共用实例内部资源,例如成员变量
MyRunnable myRunnable = new MyRunnable();
new Thread(myRunnable).start();
new Thread(myRunnable).start();

//缺点是操作线程对象不是很方便
//使用Therad获取当前线程对象
this.setName("Thread设置线程名");
//使用Runnable获取当前线程对象
Thread.currentThread().setName("Runnable设置线程名")

3. 实现callable接口

正常线程是一个个相互独立的代码块,所以,它不会有返回值,异常也不会向上抛出到主线程.
而callable是允许线程返回运行结果,并可以向上抛出异常的

  1. 实现callable接口,重写call方法
  2. 使用线程池或者 FutureTask运行callable线程
//定义一个返回值类型为String的Callable
public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        //do something
        return "返回字符串";
    }

    public static void main(String[] args) {
        MyCallable myCallable = new MyCallable();
        //使用FutureTask承载Callbale
        //Future实现接口Runnable,可以使用Thread启动
        FutureTask<String> futureTask = new FutureTask<>(myCallable);
        new Thread(futureTask).start();
        try {
        	//futureTask.get()是一个阻塞方法,阻塞到线程运行完毕后执行
            String result = futureTask.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

使用线程池来运行Callable线程

MyCallable myCallable = new MyCallable();
//线程池在本文第二部分说明
ExecutorService executorService = Executors.newCachedThreadPool();
Future<String> submit = executorService.submit(myCallable);
try {
    String result = submit.get();
} catch (InterruptedException e) {
    e.printStackTrace();
} catch (ExecutionException e) {
    e.printStackTrace();
}

线程池

服务器的线程是一种有限资源,过多的线程会占用系统资源,影响系统的稳定性.
使用线程池可以有效的管理线程资源,同时因为减少了线程创建的过程,可以有效提高程序的响应速度.

1. 手动生成线程池

ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2, 4, 30L, TimeUnit.SECONDS, 
new ArrayBlockingQueue<>(4), 
new RejectedExecutionHandler() {
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        System.out.println("线程数超过线程容量,拒绝执行任务");
    }
});

生成核心线程数2个,最大线程数4个,30s闲置销毁时间,如果超出最大线程数会出现阻塞,进入排队
这里2个核心线程数不会受销毁时间影响,如果超过2个线程数,多出来的部分,如果闲置超过30S就会被销毁,在下次需要的时候再次创建

Executors定义的4种类型,阿里巴巴提供的开发手册中不建议使用Executors来创建线程池,这里用来了解线程池的几种类型,其实最终还是用 new ThreadPoolExecutor 来生成线程池,可以参考对应的源码来实现自己需要的线程池类型.

2. 可缓存线程池 newCachedThreadPool

创建一个无限数量线程的线程池,如果线程闲置超过一定时长会自动销毁线程(默认60S)

ExecutorService executorService = Executors.newCachedThreadPool();
//支持Runnable和Future
executorService.submit(new Runnable() {
    @Override
    public void run() {
        //do something
    }
});

3. 定长线程池 newFixedThreadPool

创建一个有固定长度的线程池,并且在线程闲置的时候不会自动销毁线程
如果超过规定数量的线程需要入栈,会发生阻塞等待

//创建长度为3的线程池
ExecutorService executorService = Executors.newFixedThreadPool(3);

4. 单线程线程池 newSingleThreadExecutor

创建一个只有单线程的线程池
例如,在我主要业务完成后,需要写一些日志类的记录,但是我又不关心这类数据是否成功,就可以使用单线程线程池来进行后续的操作,并直接返回结果

//创建长度为3的线程池
ExecutorService executorService = Executors.newSingleThreadExecutor();

5. 周期性线程池 newScheduledThreadPool

初始化一个固定长度的线程池,并在首次执行时间到了后周期执行该线程,如果线程没有执行完毕,并超过线程长度,进入排队等待阶段

//定义了一个长度为3,10s后执行,每30S执行一次的周期性线程池
ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);
scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
    @Override
    public void run() {
        //do something
    }
},10L,30L,TimeUnit.SECONDS);

线程锁

多线程在访问同一个资源的时候会产生线程安全问题,所以需要一把锁来保证统一时间只能有一个线程在改变资源

1. 原子锁

当线程操作的对象是原子级的,无需加锁,因为原子操作不可分割,无需加锁

public class MultiThread implements Runnable {
    private static AtomicInteger ai = new AtomicInteger();
    @Override
    public void run() {
        for(int i=0;i<100;i++) {
            ai.incrementAndGet();
            System.out.println(ai);
        }
    }

    public static void main(String[] args) {
        MultiThread multiThread = new MultiThread();
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2,4,10L, 
                TimeUnit.SECONDS,new ArrayBlockingQueue<>(4));
        threadPoolExecutor.execute(multiThread);
        threadPoolExecutor.execute(multiThread);
        threadPoolExecutor.shutdown();
    }
}

2. 自动档 synchronized

明确的说,这是一种重量级锁,当这个资源,类对象或者类被锁定的时候,仅有一个线程可以访问,其它的线程都会等待这把锁释放
前提条件:必须是统一把锁才能达到锁的目的

public class MultiThread implements Runnable {
    private static Integer index = 0;
    @Override
    public void run() {
        for(int i=0;i<100;i++) {
            synchronized (index){
                index ++;
            }
        }
		//等同于
		for(int i=0;i<100;i++) {
            synchronized (MultiThread.class){
                index ++;
            }
        }
    }
    
	//也可等同于
	//当index不被static声明的时候
	public static synchronized void sync(){
	   index ++;
	}
}

统一把锁的情况:

  1. 同一个对象的代码块或成员变量
  2. static 声明的成员变量
  3. 锁 class(等同于 static声明的成员变量)

不是一把锁的情况,以下的情况锁会失败

  public class MultiThread implements Runnable {
  	//index不被static声明
    private Integer index = 0;
    
    @Override
    public void run() {
        for(int i=0;i<100;i++) {
            synchronized (index){
                index ++;
            }
        }
    }

    public static void main(String[] args) {
        MultiThread multiThread = new MultiThread();
        //这里重新new了一个对象
        MultiThread multiThread2 = new MultiThread();
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2,4,10L,
                TimeUnit.SECONDS,new ArrayBlockingQueue<>(4));
        threadPoolExecutor.execute(multiThread);
        threadPoolExecutor.execute(multiThread2);
    }
}

3. 手动档 Lock

使用synchronized 很方便,但是有些场景下不适用,例如我要求在针对读写场景,实现不同的锁类型,读取不锁,写锁,这个时候就要使用Lock进行锁操作

  1. ReenTrantLock 重入锁,和synchronized区别不大
public class LockThread implements Runnable {
    private Lock lock;

    public LockThread(Lock lock){
        this.lock = lock;
    }
    @Override
    public void run() {
        lock.lock();
        try {
            //do something
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        Lock lock = new ReentrantLock();
        new Thread(new LockThread(lock)).start();
        new Thread(new LockThread(lock)).start();
    }
}
  1. ReadWorkLock 读写分离锁
public class LockThread implements Runnable {
    private ReadWriteLock lock;

    public LockThread(ReadWriteLock lock){
        this.lock = lock;
    }
    @Override
    public void run() {
        lock.writeLock().lock();
        //lock.readLock().lock();
        try {
            //do something
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.writeLock().unlock();
            //lock.readLock().unlock();
        }
    }

    public static void main(String[] args) {
        ReadWriteLock lock = new ReentrantReadWriteLock();
        new Thread(new LockThread(lock)).start();
        new Thread(new LockThread(lock)).start();
    }
}

线程同步工具

1. 闭锁 CountDowmLatch

当我们主线程需要在全部线程执行完毕后,再继续执行业务,可以使用CountDowmLatch
它会阻塞主线程,并等全部其它线程执行完毕后,继续执行后续代码

public class CountDownLatchThread implements Runnable {
    private CountDownLatch countDownLatch;

    public CountDownLatchThread(CountDownLatch countDownLatch){
        this.countDownLatch = countDownLatch;
    }
    @Override
    public void run() {
        try {
            //do something
            countDownLatch.await();
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws Exception {
        CountDownLatch countDownLatch = new CountDownLatch(3);
        new Thread(new CountDownLatchThread(countDownLatch)).start();
        new Thread(new CountDownLatchThread(countDownLatch)).start();
        new Thread(new CountDownLatchThread(countDownLatch)).start();
        countDownLatch.await();
        //do something

    }
}

2. 栅栏 CyclicBarrier

当程序需要执行到某一个步骤后,再同时进入下一步骤的时候使用
例如:
赛跑程序,只有当所有人都站到起跑线的时候(资源准备完毕),再进行比赛,这样的业务可以使用CyclicBarrier来完成

public class CyclicBarrierThread implements Runnable {
    private CyclicBarrier cyclicBarrier;

    public CyclicBarrierThread(CyclicBarrier cyclicBarrier){
        this.cyclicBarrier = cyclicBarrier;
    }
    @Override
    public void run() {
        try {
            //do something
            cyclicBarrier.await();
            //do something
        }catch (BrokenBarrierException e){
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws Exception {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(3);
        new Thread(new CyclicBarrierThread(cyclicBarrier)).start();
        new Thread(new CyclicBarrierThread(cyclicBarrier)).start();
        new Thread(new CyclicBarrierThread(cyclicBarrier)).start();
    }
}

3. 阶段器 Phaser

让一个程序分阶段可控的同步进行.
例如:英语考试的时候,要所有人都听完听力才能继续答题,等全部人答完题才能进行交卷.

  1. 定义程序分几个阶段 Phaser phaser = new Phaser(2).这里就定义了两个阶段的阶段器
  2. 对参与的数量进行注册,phaser.register(),后面阶段器根据注册数量判断所有的参与者是不是都已经到达某个阶段
  3. 阶段阻塞 phaser.arriveAndAwaitAdvance() 在需要等待全员就位的位置进行阻塞等待
  4. 释放阻塞 phaser.arriveAndDeregister() ,有几个阶段就需要释放几次阻塞,相当于下一个阶段的发令枪
public class PhaserThread {
    public static void main(String[] args) {
        Phaser phaser = new Phaser(2);
        new Thread(new Thread01(phaser)).start();
        new Thread(new Thread02(phaser)).start();
        phaser.arriveAndDeregister();
        phaser.arriveAndDeregister();
    }
}

class Thread01 implements Runnable {
    private Phaser phaser;

    public Thread01(Phaser phaser) {
        phaser.register();
        this.phaser = phaser;
    }

    @Override
    public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Thread01第一阶段完成");
        phaser.arriveAndAwaitAdvance();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Thread01第二阶段完成");
        phaser.arriveAndAwaitAdvance();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Thread01第三阶段完成");
    }
}

class Thread02 implements Runnable {
    private Phaser phaser;

    public Thread02(Phaser phaser) {
        phaser.register();
        this.phaser = phaser;
    }

    @Override
    public void run() {
        try {
            Thread.sleep(4000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Thread02第一阶段完成");
        phaser.arriveAndAwaitAdvance();
        try {
            Thread.sleep(4000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Thread02第二阶段完成");
        phaser.arriveAndAwaitAdvance();
        try {
            Thread.sleep(4000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Thread02第三阶段完成");
    }
}

4. 数据交换 Exchanger

用于处理两个线程间的数据交换(只支持两个线程)

public class ExchangerThread implements Runnable {
    private Exchanger<String> exchanger;

    public ExchangerThread(Exchanger<String> exchanger){
        this.exchanger = exchanger;
    }
    @Override
    public void run() {
        try {
            //do something
            String message = exchanger.exchange("数据交换时间到");
            System.out.println(message);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws Exception {
        Exchanger exchanger = new Exchanger<String>();
        new Thread(new ExchangerThread(exchanger)).start();
        new Thread(new ExchangerThread(exchanger)).start();
    }
}

5. 信号量 Semaphore

主要功能是同一个Semaphore控制可入线程数量,超过数量的会被拦截在外,等有线程释放信号的时候才会继续

public class SemaphoreThread implements Runnable {
    private Semaphore semaphore;

    public SemaphoreThread(Semaphore semaphore){
        this.semaphore = semaphore;
    }
    @Override
    public void run() {
        try {
            semaphore.acquire();
            //do something
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            semaphore.release();
        }
    }

    public static void main(String[] args) throws Exception {
        Semaphore semaphore = new Semaphore(3);
        new Thread(new SemaphoreThread(semaphore)).start();
        new Thread(new SemaphoreThread(semaphore)).start();
        new Thread(new SemaphoreThread(semaphore)).start();
    }
}

6. wait升级 Condition

Condition 和 wait() 方法的使用过程是一样的,都是要配合锁使用
当线程获取到锁后,调用Condition或wait()都会释放锁,并等待信号继续

  1. lock.newCondition() 获取一个 Condition
  2. Conditon中的await()对应Object的wait()
  3. Condition中的signal()对应Object的notify()
  4. Condition中的signalAll()对应Object的notifyAll()
细菌V5
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程（二），线程池，同步锁，代码块等
虚空掠夺者~
08-29 385
多线程带来的数据安全问题： 1. 线程之间存在相互抢占，发生在代码的每一步，导致多线程的数据并发安全问题 2. 解决方式：加锁，主要有两种加锁的方式 - 同步代码块锁 syncronizeed(对象)---->相当于加上标记的作用 - 根据锁对象 共享进来的所有线程对象保证执行代码块中的执行内容执行权不会被抢占 1. 方法取资源被所有线程对象进行共享（耗内存） 2. 锁对象：一个对象，可以将哪些线程对象共享进来 3. 可以把当前参与的线程对象共享进来的对象（推荐写法）
进程 线程 多线程 同步锁 线程安全解决方案
m0_59841000的博客
08-19 412
1 进程 1.1概念： 进程就是正在运行的程序,它代表了程序所占用的内存区域。 1.2 进程的特点： 独立性 进程是系统中独立存在的实体,它可以拥有自己独立的资源,每个进程都拥有自己私有的地址空间,在没有经过进程本身允许的情况下,一个用户进程不可以直接访问其他进程的地址空间。动态性 进程与程序的区别在于,程序只是一个静态的指令集合,而进程是一个正在系统中活动的指令集合,程序加入了时间的概念以后,称为进程,具有自己的生命周期和各种不同的状态,这些概念都是程序所不具备的。并发性 多个进程可以在单个处理器
JavaSE进阶12：多线程、线程同步（锁）、线程池、
XXXZhy丶Blog
04-23 620
1.多线程的概念 1.1初步了解多线程 1.什么是多线程？ 采用多线程技术可以同时执行多个任务(抽烟是一个任务,听音乐是一个任务,打字是一个任务) 多线程需要硬件支持 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2aareAp3-1650346089857)(img/image-20210114221209250.png)] 现实生活中这样同时做多件事情的例子很多,看起来好像是多个任务都在做,但是本质上大脑在同一时间只做了一件事. 1.2并...
JUC Callable接口与同步锁
weixin_44130043的博客
03-29 199
Callable接口  Java 5.0 在 java.util.concurrent 提供了一个新的创建执行线程的方式：Callable 接口  Callable 接口类似于 Runnable，两者都是为那些其实例可能被另一个线程执行的类设计的。但是 Runnable 不会返回结果，并且无法抛出经过检查的异常。  Callable 需要依赖FutureTask ，FutureTask 也可...
Java 多线程（致命）面试题：线程锁+线程池+线程同步等
m0_68850571的博客
05-26 1227
1、并发编程三要素？ 1）原子性 原子性指的是一个或者多个操作，要么全部执行并且在执行的过程中不被其他操作打断，要么就全部都不执行。 2）可见性 可见性指多个线程操作一个共享变量时，其中一个线程对变量进行修改后，其他线程可以立即看到修改的结果。 实现可见性的方法： synchronized 或者 Lock：保证同一个时刻只有一个线程获取锁执行代码，锁释放之前把最新的值刷新到主内存，实现可见性。 3）有序性 有序性，即程序的执行顺序按照代码的先后顺序来执行。 2、多线程的价值？ 1...
Java多线程实战-从零手搓一个简易线程池(一)定义任务等待队列
热门推荐
qq_35716689的博客
03-25 13万+
开个新坑-手搓简易线程池。本系列文章将从零开始,一步步手工编码实现一个简单但功能完备的线程池。我们将逐步介绍线程池的各个核心组件,并分析它们的作用和实现思路。通过这个过程,我们可以更好地掌握多线程编程的技巧,并培养编码能力和系统性思维。
CVI学习文件-多线程 线程池（修改增加学习版)
01-13
通过这个学习文件，你将能掌握如何在CVI项目中合理使用多线程和线程池，提升系统的并发性能，降低资源消耗，同时避免并发问题。实践是检验理论的最好方式，通过编写和调试多线程代码，你的技能将会得到显著提升。
java学习资料-线程
06-16
此外，线程池（ExecutorService）的使用也是多线程编程中的重要部分，它可以有效地管理和控制线程，提高系统资源的利用率。 在实际开发中，正确地理解和使用线程能提升程序的并发性能，但也要注意线程安全问题，...
java多线程和锁，用于学习参考
09-09
Java多线程与锁是Java并发编程中的核心概念，它们...综上所述，Java多线程和锁是解决并发问题的关键，它们涉及线程创建、管理、同步和通信等多个方面。通过深入学习和实践，开发者能够构建出更加稳定、高效的并发程序。
Java多线程学习-动力节点共22页.pdf.zip
10-29
本资料“Java多线程学习-动力节点共22页.pdf.zip”提供了对Java多线程的深入学习，旨在帮助开发者掌握这一关键技术。 1. **线程基础**：Java中的线程是通过`Thread`类或者实现`Runnable`接口来创建的。通过继承`...
人工智能-项目实践-多线程-Java多线程高并发实例.zip
01-04
例如，可能包含使用线程池处理大量任务、使用并发容器实现数据共享、使用并发工具类进行线程同步，以及如何通过锁和原子类来保证数据一致性等。通过分析和运行这些代码，你将能够更深入地理解Java多线程在高并发场景...
保证线程安全的10个小技巧
qq_46494427的博客
06-22 4334
对于从事后端开发的同学来说，问题是我们每天都需要考虑的问题。线程安全问题通俗的讲：主要是在多线程的环境下，不同线程同时读和写公共资源（临界资源），导致的数据异常问题。比如：变量a=0，线程1给该变量+1，线程2也给该变量+1。此时，线程3获取a的值有可能不是2，而是1。线程3这不就获取了错误的数据？线程安全问题会直接导致数据异常，从而影响业务功能的正常使用，所以这个问题还是非常严重的。那么，如何解决线程安全问题呢？今天跟大家一起聊聊，保证线程安全的10个小技巧，希望对你有所帮助。我们都知道只有多个线程访问的
并发编程44题（含答案）
weixin_42034166的博客
11-21 2822
1、并发编程三要素？ 1）原子性 原子性指的是一个或者多个操作，要么全部执行并且在执行的过程中不被其他操作打断，要么就全部都不执行。 2）可见性 可见性指多个线程操作一个共享变量时，其中一个线程对变量进行修改后，其他线程可以立即看到修改的结果。 实现可见性的方法： synchronized或者Lock：保证同一个时刻只有一个线程获取锁执行代码，锁释放之前把最新的值刷新到主内存，实现可见...
多线程详解Java三种实现方式+线程安全问题+死锁问题+线程池
qq_48783543的博客
09-26 523
继承Thread类实现多线程 1、run方法（需要重写） （1）：run方法就是线程要执行任务的方法 （2）：启动线程不需要调用run方法，而是调用threa里的start方法来启动任务 （3）：main方法中的叫做主线程，它和其他线程同时执行，其中谁先执行，谁后执行是不一定的（两个线程强占时间分配）看例子： package Day1; public class Demo1 { public static void main(String[] args) { MyThread myT
简约大气毕业论文答辩PPT模板
07-11
【作品名称】：简约大气毕业论文答辩PPT模板 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
创意灯泡毕业答辩PPT模板 (2)
07-11
【作品名称】：创意灯泡毕业答辩PPT模板 (2) 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 【项目介绍】：创意灯泡毕业答辩PPT模板 (2)
总结汇报述职简介答辩培训美容课件PPT模板
07-11
【作品名称】：总结汇报述职简介答辩培训美容课件PPT模板 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
NC57固定资产.pdf
最新发布
07-11
NC57固定资产
Oracle_ERP_项目实施方案(文档模版).doc
07-11
Oracle_ERP_项目实施方案(文档模版)
92道Java多线程与并发面试题含答案（很全）
01-03
Java并发编程的核心概念包括： 线程（Thread）：线程是程序执行流的最小单元。一个进程可以有一个或多个线程，每个线程都执行其自己的任务。 进程（Process）：进程是操作系统分配资源（如内存）和调度的单位。一个进程可以包含多个线程，这些线程共享进程的资源。 并发与并行：并发是指多个任务在逻辑上同时发生，而并行是指多个任务在物理上同时发生（例如在多核处理器上）。 同步（Synchronization）：同步是控制多个线程访问共享资源的方式，以防止数据不一致和竞态条件。Java提供了多种同步机制，包括synchronized关键字、Lock接口和Semaphore类。 线程间通信（Inter-Thread Communication）：线程间通信允许线程之间共享信息和协作。 线程池（ThreadPool）：线程池是一种管理线程资源的模式，它减少了创建和销毁线程的开销，提高了系统的响应速度和吞吐量。 原子操作（Atomic Operations）：原子操作是不可中断的操作，即在多线程环境中，这些操作要么完全执行，要么完全不执行。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值