并发 订阅
并发,在操作系统中,是指一个时间段中有几个程序都处于已启动运行到运行完毕之间,且这几个程序都是在同一个处理机上运行,但任一个时刻点上只有一个程序在处理机上运行。 展开全文
并发,在操作系统中,是指一个时间段中有几个程序都处于已启动运行到运行完毕之间,且这几个程序都是在同一个处理机上运行,但任一个时刻点上只有一个程序在处理机上运行。
信息
外文名
Concurrent
拼    音
bìng fā
中文名
并发
并发词语概念
词目:并发基本解释:[] 指由己患的疾病引起[另一种病]。并发症。 [1]  引证解释:1. 同时开放。晋 傅玄 《傅子》卷三:“晔若春华之并发,馥若秋兰之俱茂。”2. 谓跟着发生。 [1] 
收起全文
精华内容
参与话题
问答
  • 同步类容器和并发类容器

    万次阅读 多人点赞 2019-07-31 19:22:20
    一.为什么会出现同步容器? 在Java的集合容器框架中,主要有四大类别:List、Set、Queue、Map。 注意Collection和Map是顶层接口,而List、Set、Queue接口则分别继承了Collection接口,分别代表数组、集合和队列这...

    一.为什么会出现同步容器?

    在Java的集合容器框架中,主要有四大类别:List、Set、Queue、Map。

    注意Collection和Map是顶层接口,而List、Set、Queue接口则分别继承了Collection接口,分别代表数组、集合和队列这三大类容器。

    像ArrayList、LinkedList都是实现了List接口,HashSet实现了Set接口,而Deque(双向队列,允许在队首、队尾进行入队和出队操作)继承了Queue接口,PriorityQueue实现了Queue接口。另外LinkedList(实际上是双向链表)同时也实现了Deque接口。

    但以上容器都是非线程安全的。如果有多个线程并发地访问这些容器时,就会出现问题。因此,在编写程序时,必须要求程序员手动地在访问到这些容器的地方进行同步处理,这样导致在使用这些容器的时候非常地不方便。所以,Java提供了同步容器供用户使用。

    二.Java中的同步类容器

    在Java中,同步容器主要包括2类:

      1)Vector、Stack、HashTable

      2)Collections类中提供的静态工厂方法创建的类

    Vector实现了List接口,Vector实际上就是一个数组,和ArrayList类似,但是Vector中的方法都是synchronized方法,即进行了同步措施;Stack也是一个同步容器,它的方法也用synchronized进行了同步,它实际上是继承于Vector类;HashTable实现了Map接口,它和HashMap很相似,但是HashTable进行了同步处理,而HashMap没有。

    Collections类是一个工具提供类,注意,它和Collection不同,Collection是一个顶层的接口。在Collections类中提供了大量的方法,比如对集合或者容器进行排序、查找等操作。最重要的是,在它里面提供了几个静态工厂方法来创建同步容器类,如下图所示:

    这些同步容器都是通过synchronized进行同步来实现线程安全的,那么很显然,这必然会影响到执行性能。

    而且虽然他们都是线程安全的,但这并不说明在任何情况下都可以线程安全,看你怎么用了,例如下面的这个例子:

    public class Test {
        static Vector<Integer> vector = new Vector<Integer>();
        public static void main(String[] args) throws InterruptedException {
            while(true) {
                for(int i=0;i<10;i++)
                    vector.add(i);
                Thread thread1 = new Thread(){
                    public void run() {
                        for(int i=0;i<vector.size();i++)
                            vector.remove(i);
                    };
                };
                Thread thread2 = new Thread(){
                    public void run() {
                        for(int i=0;i<vector.size();i++)
                            vector.get(i);
                    };
                };
                thread1.start();
                thread2.start();
                while(Thread.activeCount()>10)   {
                     
                }
            }
        }
    }

    运行结果是在执行过程中会出现数组下标越界的运行时异常。也许有朋友会问:Vector是线程安全的,为什么还会报这个错?很简单,对于Vector,虽然能保证每一个时刻只能有一个线程访问它,但是不排除这种可能,当某个线程在某个时刻执行这句时:

    for(int i=0;i<vector.size();i++)

         vector.get(i);

    假若此时vector的size方法返回的是10,i的值为9,在他要获取下标为9的元素时,有另外一个线程先执行了这句:

    for(int i=0;i<vector.size();i++)

         vector.remove(i);

    将下标为9的元素删除了,在删除过程中因为有锁,所以之前的那个线程无法执行vector.get(i);处于阻塞状态,等这个线程把下标为9的元素删除了之后获取到锁再执行。那么通过get方法访问下标为9的元素肯定就会出问题了。说明这是程序逻辑本身存在线程安全问题,因此为了保证线程安全,必须在方法调用端做额外的同步措施,如下面所示:

    public class Test {
        static Vector<Integer> vector = new Vector<Integer>();
        public static void main(String[] args) throws InterruptedException {
            while(true) {
                for(int i=0;i<10;i++)
                    vector.add(i);
                Thread thread1 = new Thread(){
                    public void run() {
                        synchronized (Test.class) {   //进行额外的同步
                            for(int i=0;i<vector.size();i++)
                                vector.remove(i);
                        }
                    };
                };
                Thread thread2 = new Thread(){
                    public void run() {
                        synchronized (Test.class) {
                            for(int i=0;i<vector.size();i++)
                                vector.get(i);
                        }
                    };
                };
                thread1.start();
                thread2.start();
                while(Thread.activeCount()>10)   {
                     
                }
            }
        }
    }

    三.Java中的并发类容器

    为了解决同步类容器的性能问题,在Java 1.5之后提供了并发容器,位于java.util.concurrent目录下,这个目录俗称并发包。

    3.1、ConcurrentMap

    ConcurrentMap接口下有两个重要的实现:ConcurrentHashMap、ConcurrentSkipListMap。ConcurrentHashMap把整个哈希表分成多个segment,每个segment一把锁,主要通过锁分段技术减小了锁的粒度,降低了冲突,从而提高了并发性。在实际的应用中,散列表一般是读多写少。ConcurrentHashMap 就针对读操作做了大量的优化,运用了很多并发技巧,如不可变对象和使用volatile保证内存可见性,这样,在大多数情况下读操作甚至无需加锁也能获得正确的值。ConcurrentHashMap的concurrencyLevel(默认值为16)表示并发级别,这个值用来确定Segment的个数,Segment的个数是大于等于concurrencyLevel的第一个2的n次方的数。比如,如果concurrencyLevel为12,13,14,15,16这些数,则Segment的数目为16(2的4次方)。理想情况下ConcurrentHashMap的真正的并发访问量能够达到concurrencyLevel,因为有concurrencyLevel个Segment,假如有concurrencyLevel个线程需要访问Map,并且需要访问的数据都恰好分别落在不同的Segment中,则这些线程能够无竞争地自由访问(因为他们不需要竞争同一把锁),达到同时访问的效果。这也是为什么这个参数起名为“并发级别”的原因。该值设置过高会照成空间的浪费,设置过低会降低并发性。这种对调优的把握是要通过对底层实现的深刻理解和不断的实践积累才能获取的。

    3.2、CopyOnWirte容器

    Cope-On-Write简称COW,是一种用于程序设计中的优化策略,称为写时复制,理解起来很简单,就是执行修改操作时进行底层数组复制,使得修改操作在新的数组上进行,不妨碍原数组的并发读操作,复制修改完成后把原数组引用指向新数组。这样做的好处是可以并发的读而不需要加锁,因为当前容器不会添加任何元素,所以也是一种读写分离的思想。但正是因为写时复制,所以不能保证数据的实时性,而只能保证最终一致性。

    在concurrent包下实现CopyOnWrite机制的容器有两种,CopyOnWriteArrayList和CopyOnWriteArraySet。

    CopyOnWriteArrayList中有一个Object数组array用来存放数据,对于set()、add()、remove()等修改数据的操作会加上重入锁ReentrantLock,等修改操作完成替换掉array的引用之后才释放锁,从而保证写操作的线程安全,而针对读操作没有任何锁。

    CopyOnWriteArraySet其实就是一个CopyOnWriteArrayList,不过就是在方法中避免重复数据而已,甚至这些避免重复数据的函数也是在CopyOnWriteArrayList中定义的,CopyOnWriteArraySet中只是包含一个CopyOnWriteArrayList的属性,然后在方法上做个包装,除了equals方法外,其他当前类中的所有函数都是调用的CopyOnWriteArrayList的方法,所以严格来讲可以使用一个CopyOnWriteArrayList作为具有Set特性的写时复制数组(不过就是没有继承AbstractSet)。

    根据CopyOnWirte容器的实现原理可知,CopyOnWirte容器保证读写分离,十分适合读多写少的场景,但不适合写多的场景。

    3.3、线程安全队列

    在并发编程中我们有时候需要使用线程安全的队列。如果我们要实现一个线程安全的队列有两种实现方式一种是使用阻塞算法,另一种是使用非阻塞算法。使用阻塞算法的队列可以用一个锁(入队和出队用同一把锁)或两个锁(入队和出队用不同的锁)等方式来实现,而非阻塞的实现方式则可以使用循环CAS的方式来实现。java.util.concurrent.atomic包相关类就是CAS的实现。

    ConcurrentLinkedQueue是一个适用于高并发场景下的非阻塞的队列,通过无锁的方式(采用CAS操作),实现了高并发状态下的高性能,通常ConcurrentLinkedQueue的性能优于BlockingQueue。ConcurrentLinkedQueue是一个基于链接节点的无界线程安全队列,它采用先进先出的规则对节点进行排序,当我们添加一个元素的时候,它会添加到队列的尾部,当我们获取一个元素时,它会返回队列头部的元素,该队列不允许NULL元素。

    阻塞队列当队列是空的时候,再想获取元素就会阻塞进入等待状态,所以非常适合生产者-消费者模式。阻塞队列BlockingQueue接口JDK提供了7种实现:

    • ArrayBlockingQueue :一个由数组结构组成的有界阻塞队列。
    • LinkedBlockingQueue :一个由链表结构组成的有界阻塞队列。
    • PriorityBlockingQueue :一个支持优先级排序的无界阻塞队列。
    • DelayQueue:一个使用优先级队列实现的无界阻塞队列。
    • SynchronousQueue:一个不存储元素的阻塞队列。
    • LinkedTransferQueue:一个由链表结构组成的无界阻塞队列。
    • LinkedBlockingDeque:一个由链表结构组成的双向阻塞队列。
    展开全文
  • JAVA高并发的三种实现

    万次阅读 多人点赞 2018-07-23 10:50:59
    是用它可以解决一切并发问题,但是,对于系统吞吐量要求更高的话,我们这提供几个小技巧。帮助大家减小锁颗粒度,提高并发能力。 初级技巧-乐观锁 乐观锁使用的场景是,读不会冲突,写会冲突。同时读的频率远大于...

    提到锁,大家肯定想到的是sychronized关键字。是用它可以解决一切并发问题,但是,对于系统吞吐量要求更高的话,我们这提供几个小技巧。帮助大家减小锁颗粒度,提高并发能力。

    初级技巧-乐观锁

    乐观锁使用的场景是,读不会冲突,写会冲突。同时读的频率远大于写。

     悲观锁的实现

    悲观的认为所有代码执行都会有并发问题,所以将所有代码块都用sychronized锁住

    乐观锁的实现

    乐观的认为在读的时候不会产生冲突为题,在写时添加锁。所以解决的应用场景是读远大于写时的场景。

    中级技巧-String.intern()

    乐观锁不能很好的解决大量的写冲突的问题,但是很多场景下,锁只是针对某个用户或者某个订单。 比如一个用户先创建session,才能进行后面的操作,但是由于网络的问题,创建session的请求和后续请求几乎同时到达,而并行线程可能会先处理后面的请求。一般情况需要对用户sessionMap加锁,比如上面的乐观锁。在这样的场景下,可以将锁限定在用户本身上,即原来的

    这个比较类似行锁和数据库表锁的概念。显然行锁的并发能力比表锁的高很多。

    实用String.intern();是这种方式的具体实现。类String维护了一个字符串池。当调用intern方法时,如果池已经包含一个等于此String对象的字符串(该对象由equals(Object)方法确定),则返回池中的字符串。可见,当String 相同时,总返回同一个对象,因此就实现了对同一用户加锁。由于所的颗粒度局限于具体用户,使得系统获得最大程度的并发。

    CopyOnWriteMap?

     

    既然说到了“类似于数据库中的行锁的概念”,就不得不提一下MVCC,Java中CopyOnWrite类实现了MVCC。Copy On Write是这样一种机制。当我们读取共享数据的时候,直接读取,不需要同步。当我们修改数据的时候,我们就把当前数据Copy一份副本,然后在这个副本 上进行修改,完成之后,再用修改后的副本,替换掉原来的数据。这种方法就叫做Copy On Write。

     

    但是,,,JDK并没有提供CopyOnWriteMap,为什么?下面有个很好的回答,那就是已经有了ConcurrentHashMap,为什么还需要CopyOnWriteMap?

     

    高级技巧 - 类ConcurrentHashMap

    String.inter()的缺陷是类 String 维护一个字符串池是放在JVM perm区的,如果用户数特别多,导致放入字符串池的String不可控,有可能导致OOM错误或者过多的Full GC。怎么样能控制锁的个数,同时减小粒度锁呢?直接使用Java ConcurrentHashMap?或者你想加入自己更精细的控制?那么可以借鉴ConcurrentHashMap的方式,将需要加锁的对象分为多个bucket,每个bucket加一个锁,伪代码如下:

     

     

     

     

     

     

    展开全文
  • 并发测试工具

    万次阅读 热门讨论 2019-06-15 14:40:47
    并发测试工具 一、Postman Postman一款非常流行的API调试工具。其实,开发人员用的更多。因为测试人员做接口测试会有更多选择,例如Jmeter、soapUI等。不过,对于开发过程中去调试接口,Postman确实足够的简单方便...

    并发测试工具

    一、Apache Bench简介

    ApacheBench 是 Apache 服务器自带的一个web压力测试工具,简称ab。ab又是一个命令行工具,对发起负载的本机要求很低,根据ab命令可以创建很多的并发访问线程,模拟多个访问者同时对某一URL地址进行访问,因此可以用来测试目标服务器的负载压力。总的来说ab工具小巧简单,上手学习较快,可以提供需要的基本性能指标,但是没有图形化结果,不能监控。

     

    使用说明

    用法很简单,使用ab命令就可以

    参数说明:
    格式:ab [options] [http://]hostname[:port]/path
    ​
    -n requests Number of requests to perform     //本次测试发起的总请求数
    -c concurrency Number of multiple requests to make   //一次产生的请求数(或并发数)
    -t timelimit Seconds to max. wait for responses    //测试所进行的最大秒数,默认没有时间限制。
    -r Don't exit on socket receive errors.     // 抛出异常继续执行测试任务 
    -p postfile File containing data to POST  //包含了需要POST的数据的文件,文件格式如“p1=1&p2=2”.使用方法是 -p 111.txt
    ​
    -T content-type Content-type header for POSTing
    //POST数据所使用的Content-type头信息,如 -T “application/x-www-form-urlencoded” 。 (配合-p)
    -v verbosity How much troubleshooting info to print
    //设置显示信息的详细程度 – 4或更大值会显示头信息, 3或更大值可以显示响应代码(404, 200等), 2或更大值可以显示警告和其他信息。 -V 显示版本号并退出。
    -C attribute Add cookie, eg. -C “c1=1234,c2=2,c3=3” (repeatable)
    //-C cookie-name=value 对请求附加一个Cookie:行。 其典型形式是name=value的一个参数对。此参数可以重复,用逗号分割。
    提示:可以借助session实现原理传递 JSESSIONID参数, 实现保持会话的功能,如-C ” c1=1234,c2=2,c3=3, JSESSIONID=FF056CD16DA9D71CB131C1D56F0319F8″ 。
    -w Print out results in HTML tables  //以HTML表的格式输出结果。默认时,它是白色背景的两列宽度的一张表。
    -i Use HEAD instead of GET
    -x attributes String to insert as table attributes
    -y attributes String to insert as tr attributes
    -z attributes String to insert as td or th attributes
    -H attribute Add Arbitrary header line, eg. ‘Accept-Encoding: gzip’ Inserted after all normal header lines. (repeatable)
    -A attribute Add Basic WWW Authentication, the attributes
    are a colon separated username and password.
    -P attribute Add Basic Proxy Authentication, the attributes are a colon separated username and password.
    -X proxy:port Proxyserver and port number to use
    -V Print version number and exit
    -k Use HTTP KeepAlive feature
    -d Do not show percentiles served table.
    -S Do not show confidence estimators and warnings.
    -g filename Output collected data to gnuplot format file.
    -e filename Output CSV file with percentages served
    -h Display usage information (this message)

    平时使用 -n 说明请求次数,-c 说明并发量就可以了

    结果解析

    Document Path:          /index.html
    Document Length:        17784 bytes     #请求文档大小
     
    Concurrency Level:      10              #并发数
    Time taken for tests:   11.898681 seconds    #全部请求完成耗时
    Complete requests:      100            #全部请求数     
    Failed requests:        0
    Write errors:           0
    Total transferred:      1805900 bytes      #总传输大小
    HTML transferred:       1778400 bytes
    Requests per second:    8.40 [#/sec] (mean)    #每秒请求数(平均)
    Time per request:       1189.868 [ms] (mean)  #每次并发请求时间(所有并发)
    Time per request:       118.987 [ms] (mean, across all concurrentrequests
    Transfer rate:          148.17 [Kbytes/sec] received    #传输速率
     
    Connection Times (ms)           #连接时间
                          min mean[+/-sd]  median(中位值)  max
    Connect: (#连接)     59   73  11.9     72     132
    Processing: (#处理)    86   998538.7     938   2288
    Waiting: (#等待)     63   135 106.8     94    663
    Total:                 155  1072540.6    1004   2362
     
    在一定比例的请求服务时间
     
     50%   1004
     66%   1260
     75%   1452
     80%   1492
     90%   1923
     95%   2078
     98%   2352
     99%   2362
     100%  2362 (longest request)

     

    三、JMeter

    Apache JMeter是Apache组织开发的基于Java的压力测试工具。用于对软件做压力测试,它最初被设计用于Web应用测 试但后来扩展到其他测试领域。 它可以用于测试静态和动态资源例如静态文件、Java 小服务程序、CGI 脚本、Java 对象、数据库, FTP 服务器, 等等。JMeter 可以用于对服务器、网络或对象模拟巨大的负载,来在不同压力类别下测试它们的强度和分析整体性能。另外,JMeter能够对应用程序做功能/回归测试,通过创建带有断言的脚本来验证你的程序返回了你期望的结果。

    使用说明

    由于JMeter功能非常强大,所以此处引用老_张的博客进行说明

    《jmeter:菜鸟入门到进阶系列》

    1、基础介绍 简单介绍jmeter的元件组成,作用等基础知识;

    2、录制脚本 简述了jmeter录制脚本的2种方式;

    3、元件的作用域及执行顺序 jmeter各元件的作用域及执行的顺序;

    4、Sampler之SOAP/XML-RPC Request 取样器中关于SOAP/XML-RPC Request的用法;

    5、Sampler之HTTP请求 取样器中关于HTTP请求的用法;

    6、http请求之content-type 取样器中关于HTTP请求的补充说明;

    7、Sample之JDBC Request 取样器中关于JDBC请求的用法;

    8、JDBC Request之Query Type 取样器中关于JDBC请求的补充说明;

    9、目录结构 jmeter目录结构等简单介绍;

    10、参数化 jmeter参数化的4种方式;

    11、关联之正则表达式提取器 jmeter关联之正则表达式提取器的用法;

    12、关联之XPath Extractor jmeter关联之XPath Extractor的用法;

    13、配置元件之计数器 jmeter配置元件中关于计数器的用法;

    14、配置元件之HTTP属性管理器 jmeter配置元件中关于http属性管理器的用法;

    15、函数助手 jmeter内置函数助手的简单介绍;

    16、定时器 jmeter八大元件之定时器的介绍;

    17、断言 jemter八大元件之断言的介绍;

    18、逻辑控制器 jmeter八大元件之逻辑控制器的介绍;

    19、常见问题及解决方法 jmeter使用过程中常见问题及解决方案的说明;

    20、阶梯式加压测试 jmeter扩展插件Stepping Thread Group的简单介绍;

    21、jmeter常用插件介绍 jmeter插件Transactions per Second、Response Times Over Time、PerfMon Metrics Collector的下载安装及使用;

    22、内存溢出原因及解决方法 关于jmeter做压力负载测试时候遇到内存溢出的原因和解决方法;

    23、jmeter分布式测试 关于高并发情况下分布式测试的一些技术点和注意事项;

    24、dubbo接口测试 利用jmeter的dubbo插件进行dubbo接口测试和性能测试;

    25、linux环境运行jmeter并生成报告 linux环境,非GUI模式运行jmeter脚本进行性能测试,并生成测试报告的介绍;

    26、jmeter生成HTML格式性能测试报告 jmeter生成HTML格式的性能测试报告的2种方式,以及可视化图表解析内容;

    结果解析

    展开全文
  • Go并发原理

    万次阅读 2019-03-05 10:59:03
    Go语言是为并发而生的语言,Go语言是为数不多的在语言层面实现并发的语言;也正是Go语言的并发特性,吸引了全球无数的开发者。 并发(concurrency)和并行(parallellism) 并发(concurrency):两个或两个以上的任务在...

    Go语言是为并发而生的语言,Go语言是为数不多的在语言层面实现并发的语言;也正是Go语言的并发特性,吸引了全球无数的开发者。

    并发(concurrency)和并行(parallellism)

    并发(concurrency):两个或两个以上的任务在一段时间内被执行。我们不必care这些任务在某一个时间点是否是同时执行,可能同时执行,也可能不是,我们只关心在一段时间内,哪怕是很短的时间(一秒或者两秒)是否执行解决了两个或两个以上任务。

    **并行(parallellism):**两个或两个以上的任务在同一时刻被同时执行。

    并发说的是逻辑上的概念,而并行,强调的是物理运行状态。并发“包含”并行。

    (详情请见:Rob Pike 的PPT

    Go的CSP并发模型

    Go实现了两种并发形式。第一种是大家普遍认知的:多线程共享内存。其实就是Java或者C++等语言中的多线程开发。另外一种是Go语言特有的,也是Go语言推荐的:CSP(communicating sequential processes)并发模型。

    CSP并发模型是在1970年左右提出的概念,属于比较新的概念,不同于传统的多线程通过共享内存来通信,CSP讲究的是“以通信的方式来共享内存”。

    请记住下面这句话:
    Do not communicate by sharing memory; instead, share memory by communicating.
    “不要以共享内存的方式来通信,相反,要通过通信来共享内存。”

    普通的线程并发模型,就是像Java、C++、或者Python,他们线程间通信都是通过共享内存的方式来进行的。非常典型的方式就是,在访问共享数据(例如数组、Map、或者某个结构体或对象)的时候,通过锁来访问,因此,在很多时候,衍生出一种方便操作的数据结构,叫做“线程安全的数据结构”。例如Java提供的包"java.util.concurrent"中的数据结构。Go中也实现了传统的线程并发模型。

    Go的CSP并发模型,是通过goroutinechannel来实现的。

    • goroutine 是Go语言中并发的执行单位。有点抽象,其实就是和传统概念上的”线程“类似,可以理解为”线程“。
    • channel是Go语言中各个并发结构体(goroutine)之前的通信机制。 通俗的讲,就是各个goroutine之间通信的”管道“,有点类似于Linux中的管道。

    生成一个goroutine的方式非常的简单:Go一下,就生成了。

    go f();
    

    通信机制channel也很方便,传数据用channel <- data,取数据用<-channel

    在通信过程中,传数据channel <- data和取数据<-channel必然会成对出现,因为这边传,那边取,两个goroutine之间才会实现通信。

    而且不管传还是取,必阻塞,直到另外的goroutine传或者取为止。

    有两个goroutine,其中一个发起了向channel中发起了传值操作。(goroutine为矩形,channel为箭头)

    左边的goroutine开始阻塞,等待有人接收。

    这时候,右边的goroutine发起了接收操作。

    右边的goroutine也开始阻塞,等待别人传送。

    这时候,两边goroutine都发现了对方,于是两个goroutine开始一传,一收。

    这便是Golang CSP并发模型最基本的形式。

    Go并发模型的实现原理

    我们先从线程讲起,无论语言层面何种并发模型,到了操作系统层面,一定是以线程的形态存在的。而操作系统根据资源访问权限的不同,体系架构可分为用户空间和内核空间;内核空间主要操作访问CPU资源、I/O资源、内存资源等硬件资源,为上层应用程序提供最基本的基础资源,用户空间呢就是上层应用程序的固定活动空间,用户空间不可以直接访问资源,必须通过“系统调用”、“库函数”或“Shell脚本”来调用内核空间提供的资源。

    我们现在的计算机语言,可以狭义的认为是一种“软件”,它们中所谓的“线程”,往往是用户态的线程,和操作系统本身内核态的线程(简称KSE),还是有区别的。

    线程模型的实现,可以分为以下几种方式:

    用户级线程模型

    如图所示,多个用户态的线程对应着一个内核线程,程序线程的创建、终止、切换或者同步等线程工作必须自身来完成。

    内核级线程模型

    这种模型直接调用操作系统的内核线程,所有线程的创建、终止、切换、同步等操作,都由内核来完成。C++就是这种。

    两级线程模型

    这种模型是介于用户级线程模型和内核级线程模型之间的一种线程模型。这种模型的实现非常复杂,和内核级线程模型类似,一个进程中可以对应多个内核级线程,但是进程中的线程不和内核线程一一对应;这种线程模型会先创建多个内核级线程,然后用自身的用户级线程去对应创建的多个内核级线程,自身的用户级线程需要本身程序去调度,内核级的线程交给操作系统内核去调度。

    Go语言的线程模型就是一种特殊的两级线程模型。暂且叫它“MPG”模型吧。

    Go线程实现模型MPG

    M指的是Machine,一个M直接关联了一个内核线程。
    P指的是"processor",代表了M所需的上下文环境,也是处理用户级代码逻辑的处理器。
    G指的是Goroutine,其实本质上也是一种轻量级的线程。

    三者关系如下图所示:

    以上这个图讲的是两个线程(内核线程)的情况。一个M会对应一个内核线程,一个M也会连接一个上下文P,一个上下文P相当于一个“处理器”,一个上下文连接一个或者多个Goroutine。P(Processor)的数量是在启动时被设置为环境变量GOMAXPROCS的值,或者通过运行时调用函数runtime.GOMAXPROCS()进行设置。Processor数量固定意味着任意时刻只有固定数量的线程在运行go代码。Goroutine中就是我们要执行并发的代码。图中P正在执行的Goroutine为蓝色的;处于待执行状态的Goroutine为灰色的,灰色的Goroutine形成了一个队列runqueues

    三者关系的宏观的图为:

    抛弃P(Processor)

    你可能会想,为什么一定需要一个上下文,我们能不能直接除去上下文,让Goroutinerunqueues挂到M上呢?答案是不行,需要上下文的目的,是让我们可以直接放开其他线程,当遇到内核线程阻塞的时候。

    一个很简单的例子就是系统调用sysall,一个线程肯定不能同时执行代码和系统调用被阻塞,这个时候,此线程M需要放弃当前的上下文环境P,以便可以让其他的Goroutine被调度执行。

    如上图左图所示,M0中的G0执行了syscall,然后就创建了一个M1(也有可能本身就存在,没创建),(转向右图)然后M0丢弃了P,等待syscall的返回值,M1接受了P,将·继续执行Goroutine队列中的其他Goroutine

    当系统调用syscall结束后,M0会“偷”一个上下文,如果不成功,M0就把它的Gouroutine G0放到一个全局的runqueue中,然后自己放到线程池或者转入休眠状态。全局runqueue是各个P在运行完自己的本地的Goroutine runqueue后用来拉取新goroutine的地方。P也会周期性的检查这个全局runqueue上的goroutine,否则,全局runqueue上的goroutines可能得不到执行而饿死。

    均衡的分配工作

    按照以上的说法,上下文P会定期的检查全局的goroutine 队列中的goroutine,以便自己在消费掉自身Goroutine队列的时候有事可做。假如全局goroutine队列中的goroutine也没了呢?就从其他运行的中的P的runqueue里偷。

    每个P中的Goroutine不同导致他们运行的效率和时间也不同,在一个有很多P和M的环境中,不能让一个P跑完自身的Goroutine就没事可做了,因为或许其他的P有很长的goroutine队列要跑,得需要均衡。
    该如何解决呢?

    Go的做法倒也直接,从其他P中偷一半!

    参考文献:
    The Go scheduler
    《Go并发编程第一版》

    更多精彩内容,请关注我的微信公众号 互联网技术窝 或者加微信共同探讨交流:

    展开全文
  • 并发编程模式

    千次阅读 多人点赞 2019-07-31 20:12:05
    一、future模式 在网上购物时,提交订单后,在收货的这段时间里无需一直在家里等候,可以先干别的事情。类推到程序设计中时,当提交请求时,期望得到答复时,如果这个答复可能很慢。传统的是一直等待到这个答复收到...
  • java并发编程之-JUC并发容器的使用

    万次阅读 2019-08-11 15:11:06
    在 Java 5.0 提供了java.util.concurrent(简称JUC)并发编程容器包,在此包中增加了在并发编程中很常用的工具类,用于定义类似于线程的自定义子系统,包括线程池,异步 IO 和轻量级任务框架;还提供了设计用于多线程上下...
  • 并发编程系列之并发编程的认识

    万次阅读 2020-05-21 14:36:46
    一个目的,为了让程序员运行的更快,但是有一点我们要知道,并不是启动越多的线程就能让程序更大限度的并发执行,在并发编程的开发中,如果希望使用更多的线程来加快程序的运行,一般我们会面临下面几种挑战:上下文...
  • Java并发编程精讲

    万人学习 2019-09-28 15:16:34
    课程会讲解Java中并发相关技术的基础、原理和应用,从线程安全、线程(池), 锁实现和并发容器等高并发Java实现,去深入理解在并发编程中, 一些最容易被忽视的点,这些点也是我在多年编程经验中实际用到, 对于每...
  • 写【高并发专题】有一段时间了,一些读者朋友留言说,并发编程很难,学习了很多的知识,但是在实际工作中却无从下手。对于一个线上产生的并发问题,又不知产生这个问题的原因究竟是什么。对于并发编程,感觉上似乎是...
  • 例子主要包括SocketAsyncEventArgs通讯封装、服务端实现日志查看、SCOKET列表、上传、下载、远程文件流、吞吐量协议,用于测试SocketAsyncEventArgs的性能和压力,最大连接数支持65535个长连接,最高命令交互速度...
  • 什么是高并发 ,详细讲解

    万次阅读 多人点赞 2017-11-20 22:36:01
    一、什么是高并发并发(High Concurrency)是互联网分布式系统架构设计中必须考虑的因素之一,它通常是指,通过设计保证系统能够同时并行处理很多请求。   高并发相关常用的一些指标有响应时间(Response ...
  • 数据库并发并发异常

    千次阅读 多人点赞 2020-05-24 18:25:41
    本文关键字:脏读、脏写、更新丢失、...在使用数据库来支撑业务系统时,随着用户量的增大,经常会遇到同时读取相同数据的情况,在没有进行并发控制的情况下就会遇到各种各样的问题,对于可能出现的问题我们要有所了解。
  • 并发编程-01并发初窥

    千次阅读 2019-02-16 02:08:33
    说来惭愧,一直没有系统的梳理过并发编程的知识,这次借着学习_Jimin_老师的《Java并发编程与高并发解决方案》课程的机会,结合以往工作中的使用,好好的梳理下并发编程与高并发的知识,形成一个较为完善的并发编程...
  • python 协程并发

    万次阅读 2018-09-17 19:12:00
    协程并发 import gevent from gevent import monkey monkey.parch_all() from socket import * from time import ctime def server(port): s=socket() s.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) s.bind((’’,port))...
  • Java 并发并发背景

    万次阅读 多人点赞 2016-12-03 22:24:51
    并发与操作系统的生命历程息息相关。进程的出现,使得程序状态的保存变为现实,为进程间的切换提供了可能,实现了操作系统的并发,大大提高资源利用率。之后,人们对实时性又有了更高的要求。由于一个进程由若干个子...
  • Jmeter并发数 测试

    万次阅读 多人点赞 2018-07-30 15:22:00
    Jmeter并发数 测试 Jmeter是一个非常好用的压力测试工具。 Jmeter用来做轻量级的压力测试,非常合适,只需要十几分钟,就能把压力测试需要的脚本写好。 阅读目录 什么是压力测试  做压力测试的常用工具 做压力...
  • 并发和并行区别秒懂

    万次阅读 多人点赞 2018-06-19 12:04:45
    你吃饭吃到一半,电话来了,你一直到吃完了以后才去接,这就说明你不支持并发也不支持并行。 你吃饭吃到一半,电话来了,你停了下来接了电话,接完后继续吃饭,这说明你支持并发。(不一定是同时的) 你吃饭吃到...
  • Java高并发秒杀API(四)之高并发优化

    万次阅读 多人点赞 2017-10-06 17:07:54
    Java高并发秒杀API(四)之高并发优化1. 高并发优化分析 关于并发 并发性上不去是因为当多个线程同时访问一行数据时,产生了事务,因此产生写锁,每当一个获取了事务的线程把锁释放,另一个排队线程才能拿到写锁,QPS...
  • Java并发API案例分析之并发设计原理

    千次阅读 多人点赞 2021-01-15 12:07:58
    并发、并行、同步、锁、线程安全……这一篇我记录了学习并发设计原理的关键知识,还有一些常用重要的Java并发编程API,学习一些关于并发程序设计的原理,弄懂来龙去脉,相对更加深入地理解并这部分知识。在学习理论...
  • 并发模拟工具

    千次阅读 2020-02-03 16:27:43
    并发模拟
  • 面试题:高并发场景下,如何保证缓存与数据库一致性? 问题分析 我们日常开发中,对于缓存用的最多的场景就像下图一样,可能仅仅是对数据进行缓存,减轻数据库压力,缩短接口响应时间。 这种方案在不需要考虑高...
  • 并发编程的第一原则,那就是不要写并发程序,所以编写正确的并发程序是一件极困难的事情,但要快速而又精准地解决“并发”类的疑难杂症,就要理解这件事情的本质,追本溯源,深入分析这些Bug的源头在哪里。 并发编程...
  • Java高并发系列4-并发容器

    千次阅读 2019-07-08 15:32:01
    Java高并发系列4-并发容器 接上一篇Java高并发系列3-再写单例我们继续, 并发容器在高并发中有这举足轻重的地步,这一篇我们主要看并发容器。 1、并发List 在List下中有ArrayList 、LinkedList 、Vector 三种数据...
  • 数据库并发控制之并发调度

    千次阅读 2018-10-25 01:08:22
    一、并发调度的可串行性 二、两段锁协议 三、封锁的粒度 四、其他并发控制机制
  • 在线用户数与并发用户数的区别和比例关系 在线用户数:用户同时在一定时间段的在线数量 并发用户数:某一时刻同时向服务器发送请求的用户数 一般而言,我们习惯以5-20的比率来推算并发用户与在线用户之间的关系。...
  • Golang 并发编程

    千次阅读 2020-08-04 10:58:37
    简而言之,所谓并发编程是指在一台处理器上“同时”处理多个任务。 随着硬件的发展,并发程序变得越来越重要。Web服务器会一次处理成千上万的请求。平板电脑和手机app在渲染用户画面同时还会后台执行各种计算任务和...
  • 都在说并发,啥是并发

    万次阅读 2017-07-14 17:27:35
    都在说并发,啥是并发?明确概念当我初入IT行业时,被各种“大神”说教。都在谈并发,有的说自己的并发几十万,有的说自己并发几千万,当时我是懵逼的。 要反忽悠,首先要明确并发的概念。 究竟啥是并发并发...
  • 当然这些都是并发编程的基本知识,除了使用这些工具以外,Java并发编程中涉及到的技术原理十分丰富。为了更好地把并发知识形成一个体系,也鉴于本人没有能力写出这类文章,于是参考几位并发编程专家的博客和书籍,做...
  • 并发编程的目的是为了让程序运行得更快,但是,并不是启动更多的线程就能让程序最大限度地并发执行。在进行并发编程时,如果希望通过多线程执行任务让程序运行得更快,会面临非常多的挑战,比如上下文切换的问题、...
  • jmeter 并发用户数,在线用户数,平均并发 峰值并发介绍: 【记录以下两个案例】 在线用户数与并发用户数的区别和比例关系 在线用户数:用户同时在一定时间段的在线数量 并发用户数:某一时刻同时向服务器发送请求的...

空空如也

1 2 3 4 5 ... 20
收藏数 370,453
精华内容 148,181
关键字:

并发