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



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多线程一定快吗？
先看下面的例子：




总结：

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

1.上下文切换
CPU通过给线程分配CPU时间片来实现多线程执行的，也就是时间片轮转机制，CPU分配给每个线程的时间片非常短，所以我们才会感觉多个线程是同事执行的。

CPU在执行执行完一个时间片后会切换到下一个任务，切换之前会保存上一个任务的状态，以便下次切换回这个任务的时候可以加载到这个任务的状态，所以任务从保存到在加载的过程就是一次上下文切换。
2.上下文切换对多线程执行的影响
因为线程有创建和上下文切换，所以多线程执行并不一定比单线程快。如果说并发量在百万次的操作串行执行会比并发线程速度快。
3.如何减少上下文的切换

无锁并发编程

每个线程对应一个内存队列里的操作
CAS算法
使用最少线程和使用协程

尽量在单线程内实现多个任务的执行

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

 

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并发编程的艺术》一文。