Java并发编程基础

1.1. 什么是并发?

1.2. 进程 vs. 线程

2. 并发的改进与问题

之所以并发号称能较快的完成某些任务是因为这些任务能被分组成多个子任务，并且这些子任务能被并行的执行。所以一个任务的实际运行效率将受限于该任务中能并行执行的部分。

一个程序理论上可达到的最高并发性能可通过以下一个被称为 Amdahl 定律来计算出：

设F为一个程序中不能被并行执行的百分比，N是处理器的数量，那么理论上该程序能获得的最高并发性能将可能是1/ (F+ ((1-F)/n)).

线程有独自的调用栈，但是又能互相访问共享的数据。所以这里你会遇到两个问题，可见性和访问。

可见性问题发生于如果线程A先读取了某些共享数据，之后线程B对这些数据进行了修改，那么线程A可能看不到线程B对这数据的改动。

访问问题发生于于 多个线程同时访问修改同一个共享数据。

可见性及访问问题将导致

3. JAVA中的并发

一个JAVA程序默认以一个线程运行在自己的进程中。JAVA语言通过Thread相关代码来支持线程。JAVA程序可通过Thread这个类来创建线程。从JAVA1.5起，在java.util.concurrent中提供了改进的并发库。

JAVA提供了“锁” 机制来保护代码片段免于被多个线程在同一时刻运行。最简单的锁住一个方法或一个类就是在该方法或类前添加synchronized关键字

在Java中synchronized关键字保证了：

对于线程间的可靠通讯及互斥访问 来说，同步是非常必要的

你可以在定义方法时使用synchronized关键字。这个关键字保证了同一时刻只有一个线程能运行这个方法。其他同样调用了这个方法的线程将被阻塞直到第一个线程离开这个方法。

public synchronized void critial() {
  // some thread critical stuff
  // here
}

你同样也能用synchronized关键字来保护方法中的代码块。这块代码将由一个关键对象来保护，该关键对象可以是个string或其他object。这个关键对象就被称为 lock。所有被相同lock保护的代码在同一时刻只能被单个线程执行。

举例来说，以下的数据结构将保证同时只有单个线程可以访问add和next方法

package de.vogella.pagerank.crawler;

import java.util.ArrayList;
import java.util.List;
/*** Data structure for a web crawler. Keeps track of the visited sites and keeps 
  * a list of sites which needs still to be crawled. 
  * @author Lars Vogel 
  */
<pre>public class CrawledSites {
  private List<String> crawledSites = new ArrayList<String>();
  private List<String> linkedSites = new ArrayList<String>();

  public void add(String site) {
    synchronized (this) {
      if (!crawledSites.contains(site)) {
        linkedSites.add(site);
      }
    }
  }
/** * Get next site to crawl. Can return null (if nothing to crawl) */
  public String next() {
    if (linkedSites.size() == 0) {
      return null;
    }
    synchronized (this) {
      <em>// Need to check again if size has changed</em>
      if (linkedSites.size() > 0) {
        String s = linkedSites.get(0);
        linkedSites.remove(0);
        crawledSites.add(s);
        return s;
      }
      return null;
    }
  }

}

如果一个变量声明时使用了 volatile 关键字，那么该关键字保证了，任何读取该变量的线程都将读到最新写进该变量的值。但 volatile 关键字不会保证变量上的任何互斥访问

As of Java 5 write access to a  volatile variable will also update non-volatile variables which were modified by the same thread. This can also be used to update values within a reference variable, e.g. for a  volatile variable person. In this case you must use a temporary variable person and use the setter to initialize the variable and then assign the temporary variable to the final variable. This will then make the address changes of this variable and the values visible to other threads.

因为在JAVA 5中，对一个声明了 volatile 的变量进行写操作会导致该写操作所在该线程之前所有的对非 volatile 变量的修改进行同步更新。这也可用来更新引用类型变量。例如，有个 volatile 类型的变量person。你必须创建一个临时变量person，然后调用SETTER方法来初始化这变量然后将临时变量赋值给final变量。 这会使这个变量的地址发生改变并且此变量的值对于其他线程变为可见。

4. JAVA 内存模型

JAVA内存模型描述了线程内存与主存间的通讯关系。

JAVA内存模型定义了线程内的内存改变将怎样传递到其他线程的规则，同样也定义了线程内存与主存进行同步的场景，也描述了哪些操作属于原子操作及操作间的顺序。

一个原子操作是指一个执行时不会被其他操作影响到的最小单位的操作。

JAVA语言规范保证了对一个变量的读和写操作都是原子的（除了LONG和DOUBLE类型的变量）。对于LONG或DOUBLE类型的变量，只有当这些变量声明时使用了volatile关键字才是原子的

假设定义了一个INT变量I，那么在java中，I++操作不是一个原子操作。同样，这对于其他数字类型的变量也都不是一个原子操作。

I++操作先从I中读取了当前值（这是个原子操作）然后再让它加上1写回（原子操作）。但是在读和写这两个操作间，I的值有可能被改变。

从JAVA1.5起，JAVA提供了原子变量，例如AtomicInteger 或 AtomicLong 都提供了类似  getAndDecrement(),  getAndIncrement() 及  getAndSet()等原子方法。

JAVA内存模型保证了每个进入相同锁同步块的线程都能看到之前进入的其他所有线程修改的结果。

您可能感兴趣的文章

• 2014 年 2 月 21 日 Oracle官方并发教程之同步 (0)
  
• 2014 年 2 月 8 日 Oracle官方教程之Fork/Join (0)
  
• 2013 年 5 月 14 日 有关“双重检查锁定失效”的说明 (3)
  
• 2014 年 4 月 15 日 Bug:LinkedTransferQueue的数据暂失和CPU爆满以及修复 (1)
  
• 2014 年 2 月 12 日 Initialization On Demand Holder idiom的实现探讨 (3)
  
• 2014 年 2 月 8 日 Oracle官方并发教程之不可变对象 (0)
  
• 2013 年 1 月 22 日 任务取消(Cancellation) (5)
  
• 2014 年 1 月 30 日 Oracle官方并发教程之Guarded Blocks (0)
  
• 2013 年 3 月 5 日 死锁 (0)
  
• 2013 年 3 月 6 日 Java中的读/写锁 (7)
  
• 2013 年 3 月 26 日 Slipped Conditions (3)
  
• 2013 年 4 月 20 日 剖析同步器 (1)
  
• 2013 年 4 月 15 日 Java同步块 (14)
  
• 2013 年 3 月 5 日 Java中的锁 (8)
  
• 2013 年 3 月 16 日 可见性问题实例 (8)