精华内容
下载资源
问答
  • 多线程一定快吗

    2015-09-03 23:50:44
    下面的代码演示串行和并发执行并累加操作的时间,可以发现:当并发累加次数不超过百万次的时候,速度会比串行执行累加操作的要慢,因为线程有创建和上下文切换的开销。

    下面的代码演示串行和并发执行并累加操作的时间,可以发现:当并发累加次数不超过百万次的时候,速度会比串行执行累加操作的要慢,因为线程有创建和上下文切换的开销。

    package com.bingfa;
    
    public class ConcurrencyTest {
    
        private static final long COUNT = 100001;
    
        public static void main(String[] args) throws InterruptedException {
            Concurrency();
            serial();
        }
    
        /**
         * currentTimeMillis() --> Returns the current time in milliseconds.
         */
        private static void serial() {
            long start = System.currentTimeMillis();
            int a = 0;
            for (long i = 0; i < COUNT; i++) {
                a += 5;
            }
            int b = 0;
            for (long i = 0; i < COUNT; i++) {
                b--;
            }
            long time = System.currentTimeMillis() - start;
            System.out.print("serial: " + time + "ms, b=" + b + ",a= " + a);
        }
    
        /**
         * InterruptedException:
         * Thrown when a thread is waiting, sleeping, or otherwise occupied,
         * and the thread is interrupted, either before or during the activity.
         * Occasionally a method may wish to test whether the current thread has been interrupted,
         * and if so, to immediately throw this exception.
         *
         * @throws InterruptedException 
         * 这个异常一般发生在线程中,当一个正在执行的线程被中断时就会出现这个异常
         * 假如有两个线程,第一个线程正在运行,第二个没有运行,这时第二个线程启动运行并要求中断第一个线程,
         * 第一个线程就会出现InterruptedException异常并执行该异常下的语句。
         */
        private static void Concurrency() throws InterruptedException {
            long start = System.currentTimeMillis();
            /* Thread类的构造方法中,需要一个实现了Runnable接口的对象,而new就是生成了个实现Runnable接口的类的一个实例对象。把这个实例作为Thread的参数
             * 接口不能实例化,new Runnable()是一个实现接口Runnable的类的对象,后面的run方法是该类里实现的方法,这是匿名内部类的写法
             */
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    int a = 0;
                    for (long i = 0; i < COUNT; i++) {
                        a += 5;
                    }
                }
            });
            /* 线程必须要先start,才能join,只有启动了,才能对线程进行操作 */
            thread.start(); // 启动thread线程
            int b = 0;
            for (int i = 0; i < COUNT; i++) {
                b--;
            }
            long time = System.currentTimeMillis() - start;
            /* join的话则是将该线程加入到调用线程(一般为主线程) 等该线程结束后 调用线程才会继续运行 */
            thread.join(); // 邀请thread线程先执行,本线程先暂停执行,等待thread线程执行完后,主线程再接着往下执行
            System.out.println("concurrency : " + time + "ms,b=" + b);
    
        }
    }
    


    结果如下

    concurrency : 3ms,b=-100001
    serial: 2ms, b=-100001,a= 500005
    Process finished with exit code 0

    如果把COUNT=1000001
    结果:

    concurrency : 6ms,b=-1000001
    serial: 7ms, b=-1000001,a= 5000005
    Process finished with exit code 0
    

    如果COUNT=100000001

    concurrency : 233ms,b=-100000001
    serial: 595ms, b=-100000001,a= 500000005
    Process finished with exit code 0
    展开全文
  • java多线程一定快吗

    2018-08-22 13:03:31
    多线程一定快吗? 先看下面的例子: 总结: 当count = 100时,同步运行的时间较短,当count = 10000时,异步运行的时间较短。看起来,并不是异步一定比同步快。这是因为在程序执行时,CPU会通过时间片...

    java多线程一定快吗?

    先看下面的例子:

    这里写图片描述
    这里写图片描述
    总结:
    当count = 100时,同步运行的时间较短,当count = 10000时,异步运行的时间较短。看起来,并不是异步一定比同步快。这是因为在程序执行时,CPU会通过时间片分配算法来循环执行任务,在多个任务之间不停的来回切换线程。当并发执行累计操作数量较小时,执行的速度会比串行慢,因为线程有创建和上下文切换的性能开销。所以,在实际使用过程中,一定要分析清楚,是否需要创建线程,如果创建了很多线程来处理很少的任务就有可能造成大量线程处于等待状态。还有一点,要尽量减少上下文的切换,如用不同的线程处理不同段的数据来减少多线程竞争锁或者用Atomic包的CAS算法来更新数据。

    下一篇:多线程的发展历史及使用场景

    展开全文
  • 多线程一定快吗

    2019-05-28 16:59:34
    CPU通过给线程分配CPU时间片来实现多线程执行的,也就是时间片轮转机制,CPU分配给每个线程的时间片非常短,所以我们才会感觉多个线程是同事执行的。 CPU在执行执行完一个时间片后会切换到下一个任务,切换之前会...

    1.上下文切换

    CPU通过给线程分配CPU时间片来实现多线程执行的,也就是时间片轮转机制,CPU分配给每个线程的时间片非常短,所以我们才会感觉多个线程是同事执行的。
    CPU在执行执行完一个时间片后会切换到下一个任务,切换之前会保存上一个任务的状态,以便下次切换回这个任务的时候可以加载到这个任务的状态,所以任务从保存到在加载的过程就是一次上下文切换。

    2.上下文切换对多线程执行的影响

    因为线程有创建和上下文切换,所以多线程执行并不一定比单线程快。如果说并发量在百万次的操作串行执行会比并发线程速度快。

    3.如何减少上下文的切换

    • 无锁并发编程
      每个线程对应一个内存队列里的操作
    • CAS算法
    • 使用最少线程和使用协程
      尽量在单线程内实现多个任务的执行
    展开全文
  • JAVA基础篇-多线程一定快吗

    千次阅读 2017-06-22 12:17:17
    下面的代码演示串行和并发执行并累加操作的时间,请分析:下面的代码并发执行一定比串行执行快吗? package chapter01; //并发和单线程执行测试 public class ConcurrencyTest { /** 执行次数 */ private ...

    下面的代码演示串行和并发执行并累加操作的时间,请分析:下面的代码并发执行一定比串行执行快吗?

     

    package chapter01;
    
    //并发和单线程执行测试
    public class ConcurrencyTest {
    	 /** 执行次数 */
    	private static final long count=10000l;
    	public static void main(String[] args) throws InterruptedException{
    		concurrency();
    		serial();
    	}
    	//并发计算
    	private static void concurrency() throws InterruptedException{
    		long start=System.currentTimeMillis();
    		Thread thread=new  Thread(new Runnable() {
    			@Override
    			public void run() {
    				int a=0;
    				for(long i=0;i<count;i++){
    					a+=5;
    				}
    			}
    		});
    		thread.start();
    		int b=0;
    		for (long i = 0; i < count; i++) {
    			b--;
    		}
    		long time=System.currentTimeMillis()-start;
    		thread.join();
    		System.out.println("concurrency :" + time + "ms,b=" + b);
    	}
    	//单线程计算
    	private static void serial(){
    		long start=System.currentTimeMillis();
    		int a=0;
    		for(long i=0;i<count;i++){
    			a+=5;
    		}
    		int b=0;
    		for (long i = 0; i < count; i++) {
    			b--;
    		}
    		long time=System.currentTimeMillis()-start;
    		System.out.println("serial:" + time + "ms,b=" + b + ",a=" + a);
    	}
    }
    

    上述问题的答案是“不一定”,测试结果如表1-1所示。

     

    从表1-1可以发现,当并发执行累加操作不超过百万次时,速度会比串行执行累加操作要慢。那么,为什么并发执行的速度会比串行慢呢?这是因为线程有创建和上下文切换的开销。
    注:本文源自《Java并发编程的艺术》一文。

    展开全文
  • 写在前面:本系列博客主要记录自己的学习过程,回顾JMM相关的东西,主要参考《java并发编程的... 就算是单核处理器也支持多线程,cpu通过给每个线程分配时间片来实现这个机制。,cpu通过不断的切换线程执行,由于比较...
  • 理解上下文切换 即使是单核处理器也支持多线程执行代码,CPU通过每个线程分配CPU时间片来实现这个机制.时间片是CPU分配给多个线程的时间,因为时间片非常短,所以CPU通过不停的切换线程执行,让我们感觉多个线程是同时...
  • 多线程一定快吗

    2021-01-20 02:54:57
    文章目录1、并发编程与多线程编程2、上下文切换2.1、原理分析2.2、测试代码2.3、如何减少上下文切换3、死锁3.1、原理分析3.2、测试代码3.3、如何解决死锁4、总结 1、并发编程与多线程编程   要了解并发编程,首先...
  • 在Windows编程中,多线程一定比单线程快吗?什么时候该用多线程?什么时候该用单线程?它们各自的应用场景是什么?
  • 多线程一定快吗?天真!

    千次阅读 2019-12-31 09:18:14
    在《多线程排序》中介绍了多线程排序,似乎看起来多线程快了很多,然而多线程就一定更快吗? 为什么多线程就不一定快? 还是拿《多线程排序-真香!》中的程序举例,下面是各个线程数量的排序结果: 线程数 时间...
  • 多线程一定比单线程快吗

    千次阅读 2018-10-24 19:22:21
    一定。因为,存在线程创建和上下文切换的时间开销。
  • 欢迎各位Java工程师朋友投稿和关注一、思考人生的多线程我们一直在说高并发、多线程、分布式应用,但是高并发情况下,多线程一定快吗?我们首先要理解下并发运行是怎么一回事。为什么一般意义上来说多线程就能抵抗...
  • 多线程并发一定比单线程快吗

    千次阅读 2019-08-02 19:19:54
    确实多线程一定情况下比单线程更快。 下面的代码演示串行和并发执行并累加操作的时间,请分析:当count的数量增加 1万 -> 10万 -> 100万 -> 1000万 -> 1亿,下面的代码并发执行一定比串行执行快吗?...
  • 并发编程与多线程编程要了解并发编程,首先要懂得与并行这个概念进行区分。并行是指两个事件同时进行,并发是CPU切换速度,看起来像是每个任务同时进行一样。多线程是实现并发编程的一种方式,假设一个场景,在...
  • 并发编程与多线程编程要了解并发编程,首先要懂得与并行这个概念进行区分。并行是指两个事件同时进行,并发是CPU切换速度,看起来像是每个任务同时进行一样。多线程是实现并发编程的一种方式,假设一个场景,在...
  • 欢迎各位Java工程师朋友投稿和关注一、思考人生的多线程我们一直在说高并发、多线程、分布式应用,但是高并发情况下,多线程一定快吗?我们首先要理解下并发运行是怎么一回事。为什么一般意义上来说多线程就能抵抗...
  • 为什么要使用多线程? 在探讨文章题目之前,我们先来思考这样一个问题,你为什么要使用多线程?我相信很多人在遇到这个问题时会不假思索的回答出答案,因为并发,那为什么并发呢? 对于多核 CPU 来说,每个物理...
  • 我们一直在说高并发、多线程、分布式应用,但是高并发情况下,多线程一定快吗? 我们首先要理解下并发运行是怎么一回事。 为什么一般意义上来说多线程就能抵抗高并发,运行速度就能得到提升? 所谓并发运行就是...

空空如也

空空如也

1 2 3 4 5 ... 14
收藏数 268
精华内容 107
热门标签
关键字:

多线程一定快吗