浅析Java并发编程(一)基础概念&理论

前言

学习Java并发编程,首先要搞清楚一些基础概念与理论,这有助于进一步的理解并发编程和写出正确有效的并发代码。本文是作者自己对Java并发编程的一些基础概念与理论的理解与总结,不对之处,望指出,共勉。

进程与线程

简而言之,进程是操作系统进行资源分配的基本单位,而线程是操作系统进行调度的基本单位,所有线程共享进程所拥有的资源。

推荐阅读:进程和线程之由来

为什么需要并发

CPU的处理速度越来越快,核心越来越多,但IO的速度相对CPU来说非常的缓慢(就像自行车与火箭)。CPU通过IO获取数据进行计算时经常需要等待,导致利用率很低,不能发挥自身速度的优势(就像一名程序员,一天可以完成一百个需求,公司却只给其配备一名产品经理,每天提一个需求)。而并发则可以更好的利用CPU,CPU同时为多个线程提供计算,当其中一个线程因IO等待时迅速切换至其他进程或线程(就像公司为这名程序员配备多名产品经理,不停的提需求,程序员不停的切换项目编写代码,充分压榨其劳动力)。

从另一种角度来说,并发其实是一种解耦合的策略,它帮助我们把做什么(目标)和什么时候做(时机)分开。这样做可以明显改进应用程序的吞吐量(获得更多的CPU调度时间)和结构(程序有多个部分在协同工作)。

并发编程的优势

  • 充分利用CPU(核心)的计算能力
  • 提高程序的吞吐量,改善性能

并发编程的劣势

  • 并发在CPU有很多空闲时间时能明显改进程序的性能,但当线程数量较多的时候,线程间频繁的调度切换反而会让系统的性能下降
  • 编写正确的并发程序是非常复杂的,即使对于很简单的问题
  • 测试并发程序是困难的,并发程序中的缺陷通常不易重现也不容易被发现

Java内存模型

JMM

Java内存模型(Java Memory Model,JMM) 是对Java并发编程中线程与内存的关系的定义,即线程间的共享变量存储在主内存(Main Memory) 中,每个线程都有一个私有的本地工作内存(Local Memory),线程的本地内存中存储了该线程使用到的共享变量的副本(从主内存复制而来),线程对该变量的所有读/写操作都必须在自己的本地内存中进行,不同的线程之间也无法直接访问对方本地内存中的变量,线程间变量值的传递需要通过与主内存同步来完成。理解Java内存模型,对于编写正确的Java并发程序来说至关重要。

all threads share the main memory. each thread uses a local working memory. refreshing local memory to/from main memory must comply to JMM rules.

推荐阅读:The Java Language Specification 17.4. Memory Model浅析JVM(二)运行时数据区深入理解Java内存模型

Java并发编程需要考虑的问题

  • 共享性

由Java内存模型得知,共享变量是所有线程共享的,如果多个线程对共享变量同时进行读/写操作程序可能会达不到预期的结果。当然,如果每个线程操作的始终是各自本地工作内存中的变量则不存在共享性问题,比如通过方法参数传入、使用局部变量、创建新的实例。有过Java Web开发经验的人都知道,Servlet就是以单实例多线程的方式工作,和每个请求相关的数据都是通过Servlet的service方法(或者是doGetdoPost方法)的参数传入的。只要Servlet中的代码只使用局部变量,Servlet就不会导致同步问题。Spring MVC的控制器也是这么做的,从请求中获得的对象都是以方法的参数传入而不是作为类的成员,很明显Struts 2的做法就正好相反,因此Struts 2中作为控制器的Action类都是每个请求对应一个实例。

  • 互斥性

互斥性指的是同一时间只允许一个线程对共享变量进行操作,以保证线程安全,具有唯一性和排它性。在Java 中通常用锁来保证共享变量的互斥性,为了提高效率通常允许多个线程同时对共享变量进行读操作,但同一时间内只允许一个线程对其进行写操作,所以锁又分为共享锁和排它锁,也叫做读锁和写锁。对于使用不变模式(被 final 修饰)的“变量”,则无需关心互斥性,因为其只允许线程对其进行读操作。(不变模式也是Java并发编程时可以考虑的一种设计。让对象的状态是不变的,如果希望修改对象的状态,就会创建对象的副本并将改变写入副本而不改变原来的对象,这样就不会出现状态不一致的情况,因此不变对象是线程安全的。Java中我们使用频率极高的String类就采用了这样的设计)

  • 原子性

原子性指的是对共享变量的操作是一个独立的、不可分割的整体。换句话说,就是一次操作,是一个连续不可中断的过程,共享变量的值不会执行到一半的时候被其他线程所修改。比如,我们经常使用的整数i++ 的操作,其实需要分成三个步骤:(1)读取整数i 的值;(2)对i进行加一操作;(3)将结果写回主内存。在多线程下该操作便会出现原子性问题,不能获得预期的值。

  • 可见性

可见性指的是当一个线程对共享变量进行更改后,其他线程对更改后的值是可见的(立即对主内存进行同步)。Java提供了volatile关键字来保证可见性。当一个共享变量被volatile修饰时,它会保证线程工作内存中修改的值会立即被更新到主内存中,其他线程也会将主内存中的新值同步至工作内存,需要注意的是volatile并不能保证原子性。

如上图所示,如果可见性得到保证,那么当线程1将X的值更改为2时,线程2内的X值也将同步为2,否则线程2内的X值仍为1。

  • 有序性

为了提高性能,编译器和处理器可能会对指令做重排序,重排序通常可以分为下面三种

  1. 编译级别的重排序,比如编译器的优化
  2. 指令级重排序,比如CPU指令执行的重排序
  3. 内存系统的重排序,比如缓存和读写缓冲区导致的重排序

有序性指的就是在多线程并发的情况下,代码实际执行的顺序、结果和单线程是一样的,不会因为重排序的问题导致结果不可预知。

<small>注:水平有限,可能理解的不够透彻,有兴趣的可以看看 Doug LeaSynchronization and the Java Memory Model,我想没有谁比他理解的更透彻了。</small>

Java中创建线程的方式

  • 方式一,继承java.lang.Thread
 public static void method1() {
        class Task extends Thread {

            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " Started");
            }
        }

        new Task().start();
    }
  • 方式二,实现java.lang.Runnable接口(推荐)
public static void method2() {
        class Task implements Runnable {

            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " Started");
            }
        }
        new Thread(new Task()).start();
    }
  • 方式三,实现java.util.concurrent.Callable接口(推荐)
public static void method3() {
        class Task implements Callable {

            @Override
            public Object call() throws Exception {
                System.out.println(Thread.currentThread().getName() + " Started");
                //求和
                return 1 + 1;
            }
        }

        ExecutorService es = Executors.newFixedThreadPool(1);
        Future future = es.submit(new Task());
        try {
            System.out.println("Calculate Completed Sum:" + future.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        es.shutdown();
    }

查看该部分源码

参考


查看《浅析Java并发编程》系列文章目录

推荐阅读更多精彩内容