Java和Scala的高并发编程

最新推荐文章于 2024-08-05 20:09:54 发布
最新推荐文章于 2024-08-05 20:09:54 发布
阅读量462 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43149023/article/details/104156656
版权

Java并发编程知识:

1. synchronized

package demo02;

/**
 * @author Jeady
 * @Date 2020/3/9
 */
public class MyRunnablesyn implements Runnable {

    static int tickets = 100;
    Object object = new Object();

    @Override
    public void run() {
        while (true){

            sell();
        }

    }

    private synchronized void sell() {
        if (tickets>0){
            System.out.println(Thread.currentThread().getName()+"正在出售:"+tickets+"张电影票");
            try {
                Thread.sleep(100);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            --tickets;
        }

    }

    public static void main(String[] args) {

        MyRunnablesyn myRunnablesyn = new MyRunnablesyn();

        Thread thread1 = new Thread(myRunnablesyn);
        thread1.setName("窗口一:");

        Thread thread2 = new Thread(myRunnablesyn);
        thread2.setName("窗口二:");

        Thread thread3 = new Thread(myRunnablesyn);
        thread3.setName("窗口三:");

        thread1.start();
        thread2.start();
        thread3.start();
    }
}

结果正常跑完:
在这里插入图片描述

2. ReentrantLock

package demo02;

import demo.Main;

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

/**
 * @author Jeady
 * @Date 2020/3/9
 */
public class MyRunnableImpl implements Runnable {

    private int ticket = 100;
    Lock  lock = new ReentrantLock();

    @Override
    public void run() {
        while (true){
            lock.lock();
            if (ticket>0){
                System.out.println(Thread.currentThread().getName()+"正在卖票"+ticket+"张电影票");
                try {
                    Thread.sleep(100);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
                --ticket;
            }
            lock.unlock();
        }

    }

    public static void main(String[] args) {
        MyRunnableImpl myRunnable = new MyRunnableImpl();

        Thread thread1 = new Thread(myRunnable);
        thread1.setName("窗口一:");

        Thread thread2 = new Thread(myRunnable);
        thread2.setName("窗口二:");

        Thread thread3 = new Thread(myRunnable);
        thread3.setName("窗口三:");

        thread1.start();
        thread2.start();
        thread3.start();
    }
}

结果:
在这里插入图片描述

3.CountDownLatch

package demo02;

import java.util.concurrent.CountDownLatch;

/**
 * @author Jeady
 * @Date 2020/3/9
 */
public class MyCountDownLatch implements Runnable {

    private CountDownLatch begin;
    private CountDownLatch end;

    public MyCountDownLatch(CountDownLatch begin, CountDownLatch end) {
        this.begin=begin;
        this.end=end;
    }

    @Override
    public void run() {
        try {
            begin.await();
            System.out.println(Thread.currentThread().getName());
            end.countDown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


    }

    public static void main(String[] args) {
        CountDownLatch begin = new CountDownLatch(1);
        CountDownLatch end = new CountDownLatch(2);

        for (int i=0;i<2;i++){
            Thread thread = new Thread(new MyCountDownLatch(begin,end));
            thread.start();
        }
        
        try {
            System.out.println("thread begin");
            begin.countDown();
            end.await();
            System.out.println("thread end");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

结果:
在这里插入图片描述

4. CyclicBarrier

循环屏障, 它允许一组线程互相等待,直到达到某个公共屏障点. 在等待线程后可以重用

package demo02;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author Jeady
 * @Date 2020/3/9
 */
public class MyCyclicBarrier {

    //等待5个线程都启动了,一起执行
    private static java.util.concurrent.CyclicBarrier cyclicBarrier  = new java.util.concurrent.CyclicBarrier(5);
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0;i<=20;i++){
            final int index = i;
            try {
                Thread.sleep(1000);
            }catch (InterruptedException e){
                e.printStackTrace();
            }

            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    go();
                }
            });
        }
        executorService.shutdown();

    }

    private static  void go() {
        System.out.println(Thread.currentThread().getName()+"准备就绪");
        try {
            cyclicBarrier.await();
            System.out.println(Thread.currentThread().getName()+"开始执行");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        }

    }


}

结果:

在这里插入图片描述

5. Semaphore

信号量, 用来限制某种资源的线程数量. 就是只允许这么多的线程使用, 一旦线程数被占满, 后面的线程就等待.

package demo02;

import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

/**
 * @author Jeady
 * @Date 2020/3/9
 */
public class MySemaogore {
    public static void main(String[] args) {

        ExecutorService executorService = Executors.newCachedThreadPool();
        Semaphore semaphore = new Semaphore(10);
        for (int i=1;i<=20;i++){
            final int index = i;
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        semaphore.acquire();
                        play();
                        semaphore.release();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
        executorService.shutdown();
    }

    private static  void play() {
        System.out.println(new Date()+""+Thread.currentThread().getName()+"获得资格");
        try {
            Thread.sleep(2000);
            System.out.println(new Date()+""+Thread.currentThread().getName()+"退出服务器");
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

结果:
在这里插入图片描述

6. 线程池:

​ java.util.concurrent.ThreadPoolExecutor 类就是一个线程池。
客户端调ThreadPoolExecutor.submit(Runnable task) 提交任务，线程池内部维护的工作者线程的数量就是该线程池的线程池大小

        当前线程池大小 ：表示线程池中实际工作者线程的数量；
        最大线程池大小 （maxinumPoolSize）：表示线程池中允许存在的工作者线程的数量上限；
        核心线程大小 （corePoolSize ）：表示一个不大于最大线程池大小的工作者线程数量上限。
        如果运行的线程少于 corePoolSize，则 Executor 始终首选添加新的线程，而不进行排队；

        如果运行的线程等于或者多于 corePoolSize，则 Executor 始终首选将请求加入队列，而不是添加新线程；

        如果无法将请求加入队列，即队列已经满了，则创建新的线程，除非创建此线程超出 maxinumPoolSize， 在这种情况下，任务将被拒绝。

ThreadPoolExecutor :

核心线程池内部实现了解吗
对于核心的几个线程池，无论是 newFixedThreadPool() 方法，newSingleThreadExecutor() 还是 newCachedThreadPool() 方法，虽然看起来创建的线程有着完全不同的功能特点，
但其实内部实现均使用了 ThreadPoolExecutor 实现，其实都只是 ThreadPoolExecutor 类的封装。
函数的参数含义如下：

            corePoolSize：指定了线程池中的线程数量
            maximumPoolSize：指定了线程池中的最大线程数量
            keepAliveTime：当线程池线程数量超过 corePoolSize 时，多余的空闲线程的存活时间。即，超过了 corePoolSize 的空闲线程，在多长时间内，会被销毁。
            unit: keepAliveTime 的单位。
            workQueue：任务队列，被提交但尚未被执行的任务。
            threadFactory：线程工厂，用于创建线程，一般用默认的即可。
            handler：拒绝策略。当任务太多来不及处理，如何拒绝任务。

Scala并发编程:

scala采用消息传递而非资源共享来实现程序的并发，消息传递通过Actor来实现的 (代码后期慢慢会补充上来)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Dx3wmitC-1580712528515)(C:\Users\lenovo\AppData\Local\Temp\1580712075925.png)]
务来中断线程。

volatile 关键字：
该关键字可以保证可见性不保证原子性。

Scala并发编程:

scala采用消息传递而非资源共享来实现程序的并发，消息传递通过Actor来实现的 (代码后期慢慢会补充上来)

[外链图片转存中…(img-Dx3wmitC-1580712528515)]

Jeady·
关注
Scala函数式编程
04-17
很大篇幅都放在，使用scala实现scala默认库文件的API中，通过对简单的函数式编程逻辑的介绍和实践，主要是实践，建立起来一个比较明晰的scala思维模式，或者叫函数式编程的思维模式。 2 无副作用的函数式编程，同时...
synchronized的4种用法
WJ S的专栏
11-21 1050
原文地址：http://hi.baidu.com/wojiubaibudu/blog/item/a27d671ed654cae6e1fe0b42.html synchronized的4种用法 1.方法声明时使用,放在范围操作符(public等)之后,返回类型声明(void等)之前.即一次只能有一个线程进入该方法,其他线程要想在此时调用该方法,只能排队等候,当前线程(就是在synchroni
Scala的锁synchronized
热门推荐
醉糊涂仙的博客
07-10 1万+
Java用法 public void sync() { synchronized(this) { ... } } Scala用法,翻译过去就是上面的Java用法 def sync() = { this.synchronized { val x = 2 } }
Scala基础入门：从零开始学习Scala编程
最新发布
weixin_41859354的博客
08-05 1437
Scala是由Martin Odersky于2003年设计的一种现代编程语言，其名称来源于“Scalable Language”（可扩展语言）。Scala运行在Java虚拟机（JVM）上，可以与Java进行无缝集成。它既支持面向对象编程，也支持函数式编程，允许开发者编写简洁、高效的代码。val：定义不可变变量（类似于Java中的finalvar：定义可变变量y = 30.5 // 允许修改// x = 15 // 不允许修改，会报错函数使用def// 函数体// 返回值使用class。
synchronized详解
Linging_24的博客
12-03 1843
1、并发编程会出现原子性、可见性、有序性问题。 原子性：在一次或多次操作中，要么所有的操作都执行并且不会受其它因素干扰而中断，要么所有的操作都不执行。在多线程环境下，线程对共享变量的操作，要么成功，要么失败，不会受其它线程的干扰。 可见性：在多线程环境下，某个线程对共享变量的修改，其它的线程可以知道并获取最新修改的值。 有序性：指程序中代码的执行顺序，java在编译时和运行时对代码进行优化，会导致程序的最终执行顺序不一定是我们Java代码编写时的顺序。 2、JVM内存模型 Java内存模型，是Java虚拟机
scala 继承java_Scala学习(八)---Scala继承
weixin_29599033的博客
02-13 394
Scala继承摘要:在本篇中，你将了解到Scala的继承与Java和C++最显著的不同。要点包括：1. extends、final关键字和Java中相同2. 重写方法时必须用override3. 只有主构造器可以调用超类的主构造器4. 你可以重写字段在本篇中，我们只探讨类继承自另一个类的情况。继承特质的内容后面会详细介绍扩展类扩展关键字Scala扩展类的方式和Java一样，使用extends关键字...
scala并发_探索Scala并发
cusi77914的博客
06-28 631
2003年，Herb Sutter在他的“免费午餐结束了”一文中揭露了业界最大的“肮脏小秘密”，清楚地表明，越来越快的处理器时代已经结束，将由一个新的并行化时代取代。单个芯片上的“核心”（虚拟CPU）。 这个消息在编程界引起了震惊，因为正确地保持线程安全的代码一直都存在，从理论上讲，即使不是在实践中，高能力的软件开发人员也对您的公司而言过于昂贵。 似乎很少有特权的人对Java的线程模型和并发A...
Scala编程 pdf
02-28
7. ** Actors模型**：Scala内置了Actors模型，用于并发编程，它基于消息传递，提供了一种安全的处理并发问题的方式。 8. **Akka框架**：虽然不是语言本身的一部分，但Akka是基于Scala构建的一个广泛使用的并发和...
Scala编程思想
12-17
Scala编程思想是现代软件开发领域中的一个重要组成部分，它结合了面向对象编程（OOP）和函数式编程（FP）的精华，为开发者提供了一种高效、灵活且强大的编程工具。以下是对Scala编程思想的深入探讨。 1. **多范式...
Scala编程.zip
05-15
3. **并发编程**：介绍Scala的Actor模型和Future API，以及如何在多线程环境中高效地操作数据。 4. **Scala与Spark集成**：解释如何使用Spark API进行分布式计算，以及如何在Scala中调用MLlib库进行机器学习。 5. **...
Scala程序设计_Java虚拟机多核编程实战
05-13
本书循序渐进地介绍了Scala的函数式编程基础，虽然篇幅短小，却切中要害。读者可以学会使用Scala静态语言的强大功能创建简洁、可扩展、...对于多核时代JVM上的并发编程，Scala是绝好的工具，而本书是你必不可少的向导。
scala并发与Java并发,Scala并发编程
weixin_39769740的博客
03-11 118
在java中，基于共享数据、加锁的线程模型，使得java并发编程越来越复杂，而在Scala中采用actor模型，不共享数据，依赖消息传递的并发编程模型object Actor_Message extends Actor {def act() {while(true){receive { //收件箱case msg => println("Message content Actor from ...
性能测试之Scala 语言、java语言下的gatling框架
qq_27947819的博客
04-28 941
性能测试工具/框架区别，gatling性能测试的使用。
大数据之Scala并发编程
大数据同盟会的博客
04-10 1330
大数据之Scala(2)
Scala如何实现并发和并行编程？
2401_85763639的博客
06-19 589
Scala是一种现代的多范式编程语言，它提供了多种工具和抽象来实现并发和并行编程。
Scala入门到精通——第二十六节 Scala并发编程基础
weixin_33937778的博客
08-15 293
作者：摇摆少年梦 视频地址：http://www.xuetuwuyou.com/course/12 本节主要内容 Scala并发编程简介 Scala Actor并发编程模型 react模型 Actor的几种状态 Actor深入使用解析 1. Scala并发编程简介 2003 年，Herb Sutter 在他的文章 “Th...
探索Scala（8）-- 关键字
zxh的专栏
11-04 1万+
本文比较一下Java和Scala语言的关键字
[java多线程]关于Java和Scala同步机制你不知道的5个真相
小虾记事
08-24 3680
实际上，所有的服务器应用在多线程中都需要某种类型的同步机制。框架已经为我们做了大多数的同步的工作，这些框架包括web服务器、数据库连接客户端、消息框架等。我们可以通过Java和Scala提供的多种组件来写出可靠的多线程应用。这些组件包括，对象池、并发集合类、高级锁、执行上下文等。 为了更好的理解这个问题，接下来首先要探究最常用的同步模式：对象锁。这种机制增强了synchroniz
探索Scala并发编程之巅：高效并行处理的艺术
2401_85761762的博客
06-23 1205
Scala的Actor模型是一种并发抽象，它将Actor作为并发执行的独立单元，通过消息传递进行通信，从而简化了并发编程。Scala提供了并行版本的集合类，如ParArray和ParVector，它们可以在多个线程上并行执行操作，从而提高程序的性能。通过本文的学习，我们深入了解了Scala中的并发和并行编程工具和方法。Scala的强大并发特性，如函数式编程、Actor模型、并行集合和并发控制机制，为开发者提供了丰富的手段来构建高效、可靠的并发应用程序。
Scala 2.12并发编程实战：从入门到高级
《Learning Concurrent Programming in Scala, 2nd Edition》不仅适合那些希望提升并发编程技能的开发者，也适合对Scala语言有基本了解，想要深入理解并利用其进行高性能并发开发的专业人士。本书遵循清晰的教程风格...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值