java线程共享数据

① java多线程程序设计详细解析

一、理解多线程
多线程是这样一种机制，它允许在程序中并发执行多个指令流，每个指令流都称为一个线程，彼此间互相独立。
线程又称为轻量级进程，它和进程一样拥有独立的执行控制，由操作系统负责调度，区别在于线程没有独立的存储空间，而是和所属进程中的其它线程共享一个存储空间，这使得线程间的通信远较进程简单。
多个线程的执行是并发的，也就是在逻辑上“同时”，而不管是否是物理上的“同时”。如果系统只有一个CPU，那么真正的“同时”是不可能的，但是由于CPU的速度非常快，用户感觉不到其中的区别，因此我们也不用关心它，只需要设想各个线程是同时执行即可。
多线程和传统的单线程在程序设计上最大的区别在于，由于各个线程的控制流彼此独立，使得各个线程之间的代码是乱序执行的，由此带来的线程调度，同步等问题，将在以后探讨。
二、在Java中实现多线凯液慎程
我们不妨设想，为了创建一个新的线程，我们需要做些什么？很显然，我们必须指明这个线程所要执行的代码，而这就是在Java中实现多线程我们所需要做的一切！
真是神奇！Java是如何做到这一点的？通过类！作为一个完全面向对象的语言，Java提供了类java.lang.Thread来方便多线程编程，这个类提供了大量的方法来方便我们控制自己的各个线程，我们以后的讨论都将围绕这个类进行。
那么如何提供给 Java 我们要线程执行的代码呢？让我们来看一看 Thread 类。Thread 类最重要的方法是run()，它为Thread类的方法start()所调用，提供我们的线程所要执行的代码。为了指定我们自己的代码，只需要覆盖它！
方法一：继承 Thread 类，覆盖方法 run()，我们在创建的 Thread 类的子类中重写 run() ,加入线程所要执行的代码即可。下面是一个例子：
public class MyThread extends Thread
{
int count= 1, number;
public MyThread(int num)
{
number = num;
System.out.println
("创建线程 " + number);
}
public void run() {
while(true) {
System.out.println
("线程 " + number + ":计数 " + count);
if(++count== 6) return;
}
}
public static void main(String args[])
{
for(int i = 0;
i 〈 5; i++) new MyThread(i+1).start();
}
}
这种方法简单明了，符合大家的习惯，但是，它也有一个很大的缺点，那就是如果我们的类已经从一个类继承（如小程序必须继承自 Applet 类），则无法再继承 Thread 类，这时如果我们又不想建立一个新的类，应该怎么办呢？
我们不妨来探索一种新的方法：我们不创建Thread类的子类，而是直接使用它，那么我们只能将我们的方法作为参数传递给 Thread 类的实例，有点类似回调函数。但是 Java 没有指针，我们只能传递一个包含这个方法的类的实例。
那么如何限制这个类盯敬必须包含这一方法呢？当然是使用接口！（虽然抽象类也可满足，但是需要继承，而我们之所以要采用这种新方法，不就是为了避免继承带来的限制吗？）
Java 提供了接口 java.lang.Runnable 来支持这种方法。
方法二：实现 Runnable 接口
Runnable接口只有一个方法run()，我们声明自己的类实现Runnable接口并提供这一方法，将我们的线程代码写入其中，就完成了这一部分的任务。但是Runnable接口并没有任何对线程的支持，我们还必须创建Thread类的实例，这一点通过Thread类的构造函数public Thread(Runnable target);来实现。下面埋禅是一个例子：
public class MyThread implements Runnable
{
int count= 1, number;
public MyThread(int num)
{
number = num;
System.out.println("创建线程 " + number);
}
public void run()
{
while(true)
{
System.out.println
("线程 " + number + ":计数 " + count);
if(++count== 6) return;
}
}
public static void main(String args[])
{
for(int i = 0; i 〈 5;
i++) new Thread(new MyThread(i+1)).start();
}
}
严格地说，创建Thread子类的实例也是可行的，但是必须注意的是，该子类必须没有覆盖 Thread 类的 run 方法，否则该线程执行的将是子类的 run 方法，而不是我们用以实现Runnable 接口的类的 run 方法，对此大家不妨试验一下。
使用 Runnable 接口来实现多线程使得我们能够在一个类中包容所有的代码，有利于封装，它的缺点在于，我们只能使用一套代码，若想创建多个线程并使各个线程执行不同的代码，则仍必须额外创建类，如果这样的话，在大多数情况下也许还不如直接用多个类分别继承 Thread 来得紧凑。
综上所述，两种方法各有千秋，大家可以灵活运用。
下面让我们一起来研究一下多线程使用中的一些问题。
三、线程的四种状态
1. 新状态：线程已被创建但尚未执行（start() 尚未被调用）。
2. 可执行状态：线程可以执行，虽然不一定正在执行。CPU 时间随时可能被分配给该线程，从而使得它执行。
3. 死亡状态：正常情况下 run() 返回使得线程死亡。调用 stop()或 destroy() 亦有同样效果，但是不被推荐，前者会产生异常，后者是强制终止，不会释放锁。
4. 阻塞状态：线程不会被分配 CPU 时间，无法执行。
四、线程的优先级
线程的优先级代表该线程的重要程度，当有多个线程同时处于可执行状态并等待获得 CPU 时间时，线程调度系统根据各个线程的优先级来决定给谁分配 CPU 时间，优先级高的线程有更大的机会获得 CPU 时间，优先级低的线程也不是没有机会，只是机会要小一些罢了。
你可以调用 Thread 类的方法 getPriority() 和 setPriority()来存取线程的优先级，线程的优先级界于1(MIN_PRIORITY)和10(MAX_PRIORITY)之间，缺省是5(NORM_PRIORITY)。
五、线程的同步
由于同一进程的多个线程共享同一片存储空间，在带来方便的同时，也带来了访问冲突这个严重的问题。Java语言提供了专门机制以解决这种冲突，有效避免了同一个数据对象被多个线程同时访问。
由于我们可以通过 private 关键字来保证数据对象只能被方法访问，所以我们只需针对方法提出一套机制，这套机制就是 synchronized 关键字，它包括两种用法：synchronized 方法和 synchronized 块。
1. synchronized 方法：通过在方法声明中加入 synchronized关键字来声明 synchronized 方法。如：
public synchronized void accessVal(int newVal);
synchronized 方法控制对类成员变量的访问：每个类实例对应一把锁，每个 synchronized 方法都必须获得调用该方法的类实例的锁方能执行，否则所属线程阻塞，方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行状态。
这种机制确保了同一时刻对于每一个类实例，其所有声明为 synchronized 的成员函数中至多只有一个处于可执行状态（因为至多只有一个能够获得该类实例对应的锁），从而有效避免了类成员变量的访问冲突（只要所有可能访问类成员变量的方法均被声明为 synchronized）。
在 Java 中，不光是类实例，每一个类也对应一把锁，这样我们也可将类的静态成员函数声明为 synchronized ，以控制其对类的静态成员变量的访问。
synchronized 方法的缺陷：若将一个大的方法声明为synchronized 将会大大影响效率，典型地，若将线程类的方法 run() 声明为 synchronized ，由于在线程的整个生命期内它一直在运行，因此将导致它对本类任何 synchronized 方法的调用都永远不会成功。当然我们可以通过将访问类成员变量的代码放到专门的方法中，将其声明为 synchronized ，并在主方法中调用来解决这一问题，但是 Java 为我们提供了更好的解决办法，那就是 synchronized 块。
2. synchronized 块：通过 synchronized关键字来声明synchronized 块。语法如下：
synchronized(syncObject)
{
//允许访问控制的代码
}
#p#副标题#e#
synchronized 块是这样一个代码块，其中的代码必须获得对象 syncObject （如前所述，可以是类实例或类）的锁方能执行，具体机制同前所述。由于可以针对任意代码块，且可任意指定上锁的对象，故灵活性较高。
六、线程的阻塞为了解决对共享存储区的访问冲突，Java 引入了同步机制，现在让我们来考察多个线程对共享资源的访问，显然同步机制已经不够了，因为在任意时刻所要求的资源不一定已经准备好了被访问，反过来，同一时刻准备好了的资源也可能不止一个。为了解决这种情况下的访问控制问题，Java 引入了对阻塞机制的支持。
阻塞指的是暂停一个线程的执行以等待某个条件发生（如某资源就绪），学过操作系统的同学对它一定已经很熟悉了。Java 提供了大量方法来支持阻塞，下面让我们逐一分析。
1. sleep() 方法：sleep() 允许 指定以毫秒为单位的一段时间作为参数，它使得线程在指定的时间内进入阻塞状态，不能得到CPU 时间，指定的时间一过，线程重新进入可执行状态。典型地，sleep() 被用在等待某个资源就绪的情形：测试发现条件不满足后，让线程阻塞一段时间后重新测试，直到条件满足为止。
2. suspend() 和 resume() 方法：两个方法配套使用，suspend()使得线程进入阻塞状态，并且不会自动恢复，必须其对应的resume() 被调用，才能使得线程重新进入可执行状态。典型地，suspend() 和 resume() 被用在等待另一个线程产生的结果的情形：测试发现结果还没有产生后，让线程阻塞，另一个线程产生了结果后，调用 resume() 使其恢复。
3. yield() 方法：yield() 使得线程放弃当前分得的 CPU 时间，但是不使线程阻塞，即线程仍处于可执行状态，随时可能再次分得 CPU 时间。调用 yield() 的效果等价于调度程序认为该线程已执行了足够的时间从而转到另一个线程。
4. wait() 和 notify() 方法：两个方法配套使用，wait() 使得线程进入阻塞状态，它有两种形式，一种允许 指定以毫秒为单位的一段时间作为参数，另一种没有参数，前者当对应的 notify() 被调用或者超出指定时间时线程重新进入可执行状态，后者则必须对应的 notify() 被调用。
初看起来它们与 suspend() 和 resume() 方法对没有什么分别，但是事实上它们是截然不同的。区别的核心在于，前面叙述的所有方法，阻塞时都不会释放占用的锁（如果占用了的话），而这一对方法则相反。
上述的核心区别导致了一系列的细节上的区别。
首先，前面叙述的所有方法都隶属于 Thread 类，但是这一对却直接隶属于 Object 类，也就是说，所有对象都拥有这一对方法。初看起来这十分不可思议，但是实际上却是很自然的，因为这一对方法阻塞时要释放占用的锁，而锁是任何对象都具有的，调用任意对象的 wait() 方法导致线程阻塞，并且该对象上的锁被释放。
而调用 任意对象的notify()方法则导致因调用该对象的 wait() 方法而阻塞的线程中随机选择的一个解除阻塞（但要等到获得锁后才真正可执行）。
其次，前面叙述的所有方法都可在任何位置调用，但是这一对方法却必须在 synchronized 方法或块中调用，理由也很简单，只有在synchronized 方法或块中当前线程才占有锁，才有锁可以释放。
同样的道理，调用这一对方法的对象上的锁必须为当前线程所拥有，这样才有锁可以释放。因此，这一对方法调用必须放置在这样的 synchronized 方法或块中，该方法或块的上锁对象就是调用这一对方法的对象。若不满足这一条件，则程序虽然仍能编译，但在运行时会出现IllegalMonitorStateException 异常。
wait() 和 notify() 方法的上述特性决定了它们经常和synchronized 方法或块一起使用，将它们和操作系统的进程间通信机制作一个比较就会发现它们的相似性：synchronized方法或块提供了类似于操作系统原语的功能，它们的执行不会受到多线程机制的干扰，而这一对方法则相当于 block 和wakeup 原语（这一对方法均声明为 synchronized）。
它们的结合使得我们可以实现操作系统上一系列精妙的进程间通信的算法（如信号量算法），并用于解决各种复杂的线程间通信问题。
关于 wait() 和 notify() 方法最后再说明两点：
第一：调用 notify() 方法导致解除阻塞的线程是从因调用该对象的 wait() 方法而阻塞的线程中随机选取的，我们无法预料哪一个线程将会被选择，所以编程时要特别小心，避免因这种不确定性而产生问题。
第二：除了 notify()，还有一个方法 notifyAll() 也可起到类似作用，唯一的区别在于，调用 notifyAll() 方法将把因调用该对象的 wait() 方法而阻塞的所有线程一次性全部解除阻塞。当然，只有获得锁的那一个线程才能进入可执行状态。
谈到阻塞，就不能不谈一谈死锁，略一分析就能发现，suspend() 方法和不指定超时期限的 wait() 方法的调用都可能产生死锁。遗憾的是，Java 并不在语言级别上支持死锁的避免，我们在编程中必须小心地避免死锁。
以上我们对 Java 中实现线程阻塞的各种方法作了一番分析，我们重点分析了 wait() 和 notify()方法，因为它们的功能最强大，使用也最灵活，但是这也导致了它们的效率较低，较容易出错。实际使用中我们应该灵活使用各种方法，以便更好地达到我们的目的。
七、守护线程
守护线程是一类特殊的线程，它和普通线程的区别在于它并不是应用程序的核心部分，当一个应用程序的所有非守护线程终止运行时，即使仍然有守护线程在运行，应用程序也将终止，反之，只要有一个非守护线程在运行，应用程序就不会终止。守护线程一般被用于在后台为其它线程提供服务。
可以通过调用方法 isDaemon() 来判断一个线程是否是守护线程，也可以调用方法 setDaemon() 来将一个线程设为守护线程。
八、线程组
线程组是一个 Java 特有的概念，在 Java 中，线程组是类ThreadGroup 的对象，每个线程都隶属于唯一一个线程组，这个线程组在线程创建时指定并在线程的整个生命期内都不能更改。
你可以通过调用包含 ThreadGroup 类型参数的 Thread 类构造函数来指定线程属的线程组，若没有指定，则线程缺省地隶属于名为 system 的系统线程组。
在 Java 中，除了预建的系统线程组外，所有线程组都必须显式创建。在 Java 中，除系统线程组外的每个线程组又隶属于另一个线程组，你可以在创建线程组时指定其所隶属的线程组，若没有指定，则缺省地隶属于系统线程组。这样，所有线程组组成了一棵以系统线程组为根的树。
Java 允许我们对一个线程组中的所有线程同时进行操作，比如我们可以通过调用线程组的相应方法来设置其中所有线程的优先级，也可以启动或阻塞其中的所有线程。
Java 的线程组机制的另一个重要作用是线程安全。线程组机制允许我们通过分组来区分有不同安全特性的线程，对不同组的线程进行不同的处理，还可以通过线程组的分层结构来支持不对等安全措施的采用。
Java 的 ThreadGroup 类提供了大量的方法来方便我们对线程组树中的每一个线程组以及线程组中的每一个线程进行操作。
九、总结
在本文中，我们讲述了 Java 多线程编程的方方面面，包括创建线程，以及对多个线程进行调度、管理。我们深刻认识到了多线程编程的复杂性，以及线程切换开销带来的多线程程序的低效性，这也促使我们认真地思考一个问题：我们是否需要多线程？何时需要多线程？
多线程的核心在于多个代码块并发执行，本质特点在于各代码块之间的代码是乱序执行的。我们的程序是否需要多线程，就是要看这是否也是它的内在特点。
假如我们的程序根本不要求多个代码块并发执行，那自然不需要使用多线程；假如我们的程序虽然要求多个代码块并发执行，但是却不要求乱序，则我们完全可以用一个循环来简单高效地实现，也不需要使用多线程；只有当它完全符合多线程的特点时，多线程机制对线程间通信和线程管理的强大支持才能有用武之地，这时使用多线程才是值得的。
#p#副标题#e#

② Java 理论与实践: 正确使用 volatile 变量 线程同步

Java语言规范中指出 为了获得最佳速度 允许线程保存共享成员变量的私有拷贝 而且只当线程进入或者离开同步代码块时才与共享成员变量的原始值对比

这样当多个线程蔽握同时与某个对象交互时 就必须要注意到要让线程及时的得到共享成员变量的变化

而volatile关键字就是提示VM:对于这个成员变量不能保存它的私有拷贝 而应直接与共享成员变量交互

使用建议 在两个或者更多的线程访问的成员变量上使用volatile 当要访问慎并卖的变量已在synchronized代码块中 或者为常量时 不必使用

由于使用volatile屏蔽掉了VM中必要的代码优化 所以在效率上比较低 因此一定在宽逗必要时才使用此关键字

Java的serialization提供了一种持久化对象实例的机制 当持久化对象时 可能有一个特殊的对象数据成员 我们不想用serialization机制来保存它 为了在一个特定对象的一个域上关闭serialization 可以在这个域前加上关键字transient

transient是Java语言的关键字 用来表示一个域不是该对象串行化的一部分 当一个对象被串行化的时候 transient型变量的值不包括在串行化的表示中 然而非transient型的变量是被包括进去的

注意static变量也是可以串行化的

Java 语言中的 volatile 变量可以被看作是一种 程度较轻的 synchronized ;与 synchronized 块相比 volatile 变量所需的编码较少 并且运行时开销也较少 但是它所能实现的功能也仅是 synchronized 的一部分 本文介绍了几种有效使用 volatile 变量的模式 并强调了几种不适合使用 volatile 变量的情形

锁提供了两种主要特性 互斥（mutual exclusion） 和可见性（visibility） 互斥即一次只允许一个线程持有某个特定的锁 因此可使用该特性实现对共享数据的协调访问协议 这样 一次就只有一个线程能够使用该共享数据 可见性要更加复杂一些 它必须确保释放锁之前对共享数据做出的更改对于随后获得该锁的另一个线程是可见的 如果没有同步机制提供的这种可见性保证 线程看到的共享变量可能是修改前的值或不一致的值 这将引发许多严重问题

Volatile 变量

Volatile 变量具有 synchronized 的可见性特性 但是不具备原子特性 这就是说线程能够自动发现 volatile 变量的最新值 Volatile 变量可用于提供线程安全 但是只能应用于非常有限的一组用例 多个变量之间或者某个变量的当前值与修改后值之间没有约束 因此 单独使用 volatile 还不足以实现计数器 互斥锁或任何具有与多个变量相关的不变式（Invariants）的类（例如 start <=end ）

出于简易性或可伸缩性的考虑 您可能倾向于使用 volatile 变量而不是锁 当使用 volatile 变量而非锁时 某些习惯用法（idiom）更加易于编码和阅读 此外 volatile 变量不会像锁那样造成线程阻塞 因此也很少造成可伸缩性问题 在某些情况下 如果读操作远远大于写操作 volatile 变量还可以提供优于锁的性能优势

正确使用 volatile 变量的条件

您只能在有限的一些情形下使用 volatile 变量替代锁 要使 volatile 变量提供理想的线程安全 必须同时满足下面两个条件

对变量的写操作不依赖于当前值

该变量没有包含在具有其他变量的不变式中

实际上 这些条件表明 可以被写入 volatile 变量的这些有效值独立于任何程序的状态 包括变量的当前状态

第一个条件的限制使 volatile 变量不能用作线程安全计数器 虽然增量操作（x++）看上去类似一个单独操作 实际上它是一个由读取 修改 写入操作序列组成的组合操作 必须以原子方式执行 而 volatile 不能提供必须的原子特性 实现正确的操作需要使 x 的值在操作期间保持不变 而 volatile 变量无法实现这点 （然而 如果将值调整为只从单个线程写入 那么可以忽略第一个条件 ）

大多数编程情形都会与这两个条件的其中之一冲突 使得 volatile 变量不能像 synchronized 那样普遍适用于实现线程安全 清单 显示了一个非线程安全的数值范围类 它包含了一个不变式 下界总是小于或等于上界

清单 非线程安全的数值范围类

@NotThreadSafe

public class NumberRange {

private int lower upper;

public int getLower（） { return lower; }

public int getUpper（） { return upper; }

public void setLower（int value） {

if （value > upper）

throw new IllegalArgumentException（…）

lower = value;

}

public void setUpper（int value） {

if （value < lower）

throw new IllegalArgumentException（…）

upper = value;

}

}

这种方式限制了范围的状态变量 因此将 lower 和 upper 字段定义为 volatile 类型不能够充分实现类的线程安全 从而仍然需要使用同步 否则 如果凑巧两个线程在同一时间使用不一致的值执行 setLower 和 setUpper 的话 则会使范围处于不一致的状态 例如 如果初始状态是 （ ） 同一时间内 线程 A 调用 setLower（ ） 并且线程 B 调用 setUpper（ ） 显然这两个操作交叉存入的值是不符合条件的 那么两个线程都会通过用于保护不变式的检查 使得最后的范围值是 （ ） 一个无效值 至于针对范围的其他操作 我们需要使 setLower（） 和 setUpper（） 操作原子化 而将字段定义为 volatile 类型是无法实现这一目的的

性能考虑

使用 volatile 变量的主要原因是其简易性 在某些情形下 使用 volatile 变量要比使用相应的锁简单得多 使用 volatile 变量次要原因是其性能 某些情况下 volatile 变量同步机制的性能要优于锁

很难做出准确 全面的评价 例如 X 总是比 Y 快 尤其是对 JVM 内在的操作而言 （例如 某些情况下 VM 也许能够完全删除锁机制 这使得我们难以抽象地比较 volatile和 synchronized 的开销 ）就是说 在目前大多数的处理器架构上 volatile 读操作开销非常低 几乎和非 volatile 读操作一样 而 volatile 写操作的开销要比非 volatile 写操作多很多 因为要保证可见性需要实现内存界定（Memory Fence） 即便如此 volatile 的总开销仍然要比锁获取低

volatile 操作不会像锁一样造成阻塞 因此 在能够安全使用 volatile 的情况下 volatile 可以提供一些优于锁的可伸缩特性 如果读操作的次数要远远超过写操作 与锁相比 volatile 变量通常能够减少同步的性能开销

正确使用 volatile 的模式

很多并发性专家事实上往往引导用户远离 volatile 变量 因为使用它们要比使用锁更加容易出错 然而 如果谨慎地遵循一些良好定义的模式 就能够在很多场合内安全地使用 volatile 变量 要始终牢记使用 volatile 的限制 只有在状态真正独立于程序内其他内容时才能使用 volatile 这条规则能够避免将这些模式扩展到不安全的用例

模式 # :状态标志

也许实现 volatile 变量的规范使用仅仅是使用一个布尔状态标志 用于指示发生了一个重要的一次性事件 例如完成初始化或请求停机

很多应用程序包含了一种控制结构 形式为 在还没有准备好停止程序时再执行一些工作 如清单 所示

清单 将 volatile 变量作为状态标志使用

volatile boolean shutdownRequested;

…

public void shutdown（） { shutdownRequested = true; }

public void doWork（） {

while （！shutdownRequested） {

// do stuff

}

}

很可能会从循环外部调用 shutdown（） 方法 即在另一个线程中 因此 需要执行某种同步来确保正确实现 shutdownRequested 变量的可见性 （可能会从 JMX 侦听程序 GUI 事件线程中的操作侦听程序 通过 RMI 通过一个 Web 服务等调用） 然而 使用 synchronized 块编写循环要比使用清单 所示的 volatile 状态标志编写麻烦很多 由于 volatile 简化了编码 并且状态标志并不依赖于程序内任何其他状态 因此此处非常适合使用 volatile

这种类型的状态标记的一个公共特性是 通常只有一种状态转换 shutdownRequested 标志从 false 转换为 true 然后程序停止 这种模式可以扩展到来回转换的状态标志 但是只有在转换周期不被察觉的情况下才能扩展（从 false 到 true 再转换到 false） 此外 还需要某些原子状态转换机制 例如原子变量

模式 # :一次性安全发布（one time safe publication）

缺乏同步会导致无法实现可见性 这使得确定何时写入对象引用而不是原语值变得更加困难 在缺乏同步的情况下 可能会遇到某个对象引用的更新值（由另一个线程写入）和该对象状态的旧值同时存在 （这就是造成着名的双重检查锁定（double checked locking）问题的根源 其中对象引用在没有同步的情况下进行读操作 产生的问题是您可能会看到一个更新的引用 但是仍然会通过该引用看到不完全构造的对象）

实现安全发布对象的一种技术就是将对象引用定义为 volatile 类型 清单 展示了一个示例 其中后台线程在启动阶段从数据库加载一些数据 其他代码在能够利用这些数据时 在使用之前将检查这些数据是否曾经发布过

清单 将 volatile 变量用于一次性安全发布

public class BackgroundFloobleLoader {

public volatile Flooble theFlooble;

public void initInBackground（） {

// do lots of stuff

theFlooble = new Flooble（） // this is the only write to theFlooble

}

}

public class SomeOtherClass {

public void doWork（） {

while （true） {

// do some stuff…

// use the Flooble but only if it is ready

if （floobleLoader theFlooble != null）

doSomething（floobleLoader theFlooble）

}

}

}

如果 theFlooble 引用不是 volatile 类型 doWork（） 中的代码在解除对 theFlooble 的引用时 将会得到一个不完全构造的 Flooble

该模式的一个必要条件是 被发布的对象必须是线程安全的 或者是有效的不可变对象（有效不可变意味着对象的状态在发布之后永远不会被修改） volatile 类型的引用可以确保对象的发布形式的可见性 但是如果对象的状态在发布后将发生更改 那么就需要额外的同步

模式 # :独立观察（independent observation）

安全使用 volatile 的另一种简单模式是 定期 发布 观察结果供程序内部使用 例如 假设有一种环境传感器能够感觉环境温度 一个后台线程可能会每隔几秒读取一次该传感器 并更新包含当前文档的 volatile 变量 然后 其他线程可以读取这个变量 从而随时能够看到最新的温度值

使用该模式的另一种应用程序就是收集程序的统计信息 清单 展示了身份验证机制如何记忆最近一次登录的用户的名字 将反复使用 lastUser 引用来发布值 以供程序的其他部分使用

清单 将 volatile 变量用于多个独立观察结果的发布

public class UserManager {

public volatile String lastUser;

public boolean authenticate（String user String password） {

boolean valid = passwordIsValid（user password）

if （valid） {

User u = new User（）

activeUsers add（u）

lastUser = user;

}

return valid;

}

}

该模式是前面模式的扩展 将某个值发布以在程序内的其他地方使用 但是与一次性事件的发布不同 这是一系列独立事件 这个模式要求被发布的值是有效不可变的 即值的状态在发布后不会更改 使用该值的代码需要清楚该值可能随时发生变化

模式 # : volatile bean 模式

volatile bean 模式适用于将 JavaBeans 作为 荣誉结构 使用的框架 在 volatile bean 模式中 JavaBean 被用作一组具有 getter 和/或 setter 方法 的独立属性的容器 volatile bean 模式的基本原理是 很多框架为易变数据的持有者（例如 HttpSession）提供了容器 但是放入这些容器中的对象必须是线程安全的

在 volatile bean 模式中 JavaBean 的所有数据成员都是 volatile 类型的 并且 getter 和 setter 方法必须非常普通 除了获取或设置相应的属性外 不能包含任何逻辑 此外 对于对象引用的数据成员 引用的对象必须是有效不可变的 （这将禁止具有数组值的属性 因为当数组引用被声明为 volatile 时 只有引用而不是数组本身具有 volatile 语义） 对于任何 volatile 变量 不变式或约束都不能包含 JavaBean 属性 清单 中的示例展示了遵守 volatile bean 模式的 JavaBean:

清单 遵守 volatile bean 模式的 Person 对象

@ThreadSafe

public class Person {

private volatile String firstName;

private volatile String lastName;

private volatile int age;

public String getFirstName（） { return firstName; }

public String getLastName（） { return lastName; }

public int getAge（） { return age; }

public void setFirstName（String firstName） {

this firstName = firstName;

}

public void setLastName（String lastName） {

this lastName = lastName;

}

public void setAge（int age） {

this age = age;

}

}

volatile 的高级模式

前面几节介绍的模式涵盖了大部分的基本用例 在这些模式中使用 volatile 非常有用并且简单 这一节将介绍一种更加高级的模式 在该模式中 volatile 将提供性能或可伸缩性优势

volatile 应用的的高级模式非常脆弱 因此 必须对假设的条件仔细证明 并且这些模式被严格地封装了起来 因为即使非常小的更改也会损坏您的代码！同样 使用更高级的 volatile 用例的原因是它能够提升性能 确保在开始应用高级模式之前 真正确定需要实现这种性能获益 需要对这些模式进行权衡 放弃可读性或可维护性来换取可能的性能收益 如果您不需要提升性能（或者不能够通过一个严格的测试程序证明您需要它） 那么这很可能是一次糟糕的交易 因为您很可能会得不偿失 换来的东西要比放弃的东西价值更低

模式 # :开销较低的读 写锁策略

目前为止 您应该了解了 volatile 的功能还不足以实现计数器 因为 ++x 实际上是三种操作（读 添加 存储）的简单组合 如果多个线程凑巧试图同时对 volatile 计数器执行增量操作 那么它的更新值有可能会丢失

然而 如果读操作远远超过写操作 您可以结合使用内部锁和 volatile 变量来减少公共代码路径的开销 清单 中显示的线程安全的计数器使用 synchronized 确保增量操作是原子的 并使用 volatile 保证当前结果的可见性 如果更新不频繁的话 该方法可实现更好的性能 因为读路径的开销仅仅涉及 volatile 读操作 这通常要优于一个无竞争的锁获取的开销

清单 结合使用 volatile 和 synchronized 实现 开销较低的读 写锁

清单 结合使用 volatile 和 synchronized 实现 开销较低的读 写锁 单 结合使用 volatile 和 synchronized 实现 开销较低的读 写锁

@ThreadSafe

public class CheesyCounter {

// Employs the cheap read write lock trick

// All mutative operations MUST be done with the this lock held

@GuardedBy（ this ） private volatile int value;

public int getValue（） { return value; }

public synchronized int increment（） {

return value++;

}

}

之所以将这种技术称之为 开销较低的读 写锁 是因为您使用了不同的同步机制进行读写操作 因为本例中的写操作违反了使用 volatile 的第一个条件 因此不能使用 volatile 安全地实现计数器 您必须使用锁 然而 您可以在读操作中使用 volatile 确保当前值的可见性 因此可以使用锁进行所有变化的操作 使用 volatile 进行只读操作 其中 锁一次只允许一个线程访问值 volatile 允许多个线程执行读操作 因此当使用 volatile 保证读代码路径时 要比使用锁执行全部代码路径获得更高的共享度 就像读 写操作一样 然而 要随时牢记这种模式的弱点 如果超越了该模式的最基本应用 结合这两个竞争的同步机制将变得非常困难

结束语

③ java并发常识

1.java并发编程是什么
1， 保证线程安全的三种方法： a， 不要跨线程访问共享变量b， 使共享变量是final类型的c， 将共享变量的操作加上同步 2， 一开始就将类设计成线程安全的， 比在后期重新修复它，更容易。

3， 编写多线程程序， 首先保证它是正确的， 其次再考虑性能。 4， 无状态或只读对象永远是线程安全的。

5， 不要将一个共享变量 *** 在多线程环境下（无同步或不可变性保护） 6， 多线程环境下的延迟加载需要同步的保护， 因为延迟加载会造成对象重复实例化 7， 对于volatile声明的数值类型变量进行运算， 往往是不安全的（volatile只能保证可见性，不能保证原子性）。 详见volatile原理与技巧中， 脏数据问题讨论。

8， 当一个线程请求获得它自己占有的锁时（同一把锁的嵌套使用）， 我们称该锁为可重入锁。在jdk1。

5并发包中， 提供了可重入锁的java实现-ReentrantLock。 9， 每个共享变量，都应该由一个唯一确定的锁保护。

创建与变量相同数目的ReentrantLock， 使他们负责每个变量的线程安全。 10，虽然缩小同步块的范围， 可以提升系统性能。

但在保证原子性的情况下， 不可将原子操作分解成多个synchronized块。 11， 在没有同步的情况下， 编译器与处理器运行时的指令执行顺序可能完全出乎意料。

原因是， 编译器或处理器为了优化自身执行效率， 而对指令进行了的重排序（reordering）。 12， 当一个线程在没有同步的情况下读取变量， 它可能会得到一个过期值， 但是至少它可以看到那个线程在当时设定的一个真实数值。

而不是凭空而来的值。 这种安全保证， 称之为最低限的安全性（out-of-thin-air safety） 在开发并发应用程序时， 有时为了大幅度提高系统的吞吐量与性能， 会采用这种无保障的做法。

但是针对， 数值的运算， 仍旧是被否决的。 13, volatile变量，只能保证可见性， 无法保证原子性。

14， 某些耗时较长的网络操作或IO， 确保执行时， 不要占有锁。 15， 发布（publish）对象， 指的是使它能够被当前范围之外的代码所使用。

（引用传递）对象逸出（escape）， 指的是一个对象在尚未准备好时将它发布。 原则： 为防止逸出， 对象必须要被完全构造完后， 才可以被发布（最好的解决方式是采用同步） this关键字引用对象逸出 例子： 在构造函数中， 开启线程， 并将自身对象this传入线程， 造成引用传递。

而此时， 构造函数尚未执行完， 就会发生对象逸出了。 16， 必要时， 使用ThreadLocal变量确保线程封闭性（封闭线程往往是比较安全的， 但一定程度上会造成性能损耗）封闭对象的例子在实际使用过程中， 比较常见， 例如 hibernate openSessionInView机制， jdbc的connection机制。

17， 单一不可变对象往往是线程安全的（复杂不可变对象需要保证其内部成员变量也是不可变的）良好的多线程编程习惯是： 将所有的域都声明为final， 除非它们是可变的。
2.Java线程并发协作是什么
线程发生死锁可能性很小，即使看似可能发生死锁的代码，在运行时发生死锁的可能性也是小之又小。

发生死锁的原因一般是两个对象的锁相互等待造成的。 在《Java线程：线程的同步与锁》一文中，简述死锁的概念与简单例子，但是所给的例子是不完整的，这里给出一个完整的例子。

/** * Java线程：并发协作-死锁 * * @author Administrator 2009-11-4 22:06:13 */ public class Test { public static void main(String[] args) { DeadlockRisk dead = new DeadlockRisk(); MyThread t1 = new MyThread(dead, 1, 2); MyThread t2 = new MyThread(dead, 3, 4); MyThread t3 = new MyThread(dead, 5, 6); MyThread t4 = new MyThread(dead, 7, 8); t1。 start(); t2。

start(); t3。start(); t4。

start(); } } class MyThread extends Thread { private DeadlockRisk dead; private int a, b; MyThread(DeadlockRisk dead, int a, int b) { this。 dead = dead; this。

a = a; this。b = b; } @Override public void run() { dead。

read(); dead。write(a, b); } } class DeadlockRisk { private static class Resource { public int value; }。
3.如何学习Java高并发
1.学习 *** 并发框架的使用，如ConcurrentHashMAP,CopyOnWriteArrayList/Set等2.几种并发锁的使用以及线程同步与互斥，如ReentainLock,synchronized,Lock,CountDownLatch,Semaphore等3.线程池如Executors,ThreadPoolExecutor等4.Runable,Callable,RescureTask,Future,FutureTask等5.Fork-Join框架以上基本包含完了，如有缺漏请原谅。
4.并发编程的Java抽象有哪些呢
一、机器和OS级别抽象 （1）冯诺伊曼模型 经典的顺序化计算模型，貌似可以保证顺序化一致性，但是没有哪个现代的多处理架构会提供顺序一致性，冯氏模型只是现代多处理器行为的模糊近似。

这个计算模型，指令或者命令列表改变内存变量直接契合命令编程泛型，它以显式的算法为中心，这和声明式编程泛型有区别。 就并发编程来说，会显着的引入时间概念和状态依赖 所以所谓的函数式编程可以解决其中的部分问题。

（2）进程和线程 进程抽象运行的程序，是操作系统资源分配的基本单位，是资源cpu，内存，IO的综合抽象。 线程是进程控制流的多重分支，它存在于进程里，是操作系统调度的基本单位，线程之间同步或者异步执行，共享进程的内存地址空间。

（3）并发与并行 并发，英文单词是concurrent，是指逻辑上同时发生，有人做过比喻，要完成吃完三个馒头的任务，一个人可以这个馒头咬一口，那个馒头咬一口，这样交替进行，最后吃完三个馒头，这就是并发，因为在三个馒头上同时发生了吃的行为，如果只是吃完一个接着吃另一个，这就不是并发了，是排队，三个馒头如果分给三个人吃，这样的任务完成形式叫并行，英文单词是parallel。 回到计算机概念，并发应该是单CPU时代或者单核时代的说法，这个时候CPU要同时完成多任务，只能用时间片轮转，在逻辑上同时发生，但在物理上是串行的。

现在大多数计算机都是多核或者多CPU，那么现在的多任务执行方式就是物理上并行的。 为了从物理上支持并发编程，CPU提供了相应的特殊指令，比如原子化的读改写，比较并交换。

（4）平台内存模型 在可共享内存的多处理器体系结构中，每个处理器都有它自己的缓存，并且周期性的与主存同步，为什么呢？因为处理器通过降低一致性来换取性能，这和CAP原理通过降低一致性来获取伸缩性有点类似，所以大量的数据在CPU的寄存器中被计算，另外CPU和编译器为了性能还会乱序执行，但是CPU会提供存储关卡指令来保证存储的同步，各种平台的内存模型或者同步指令可能不同，所以这里必须介入对内存模型的抽象，JMM就是其中之一。 二、编程模型抽象 （1）基于线程模型 （2）基于Actor模型 （3）基于STM软件事务内存 …… Java体系是一个基于线程模型的本质编程平台，所以我们主要讨论线程模型。

三、并发单元抽象 大多数并发应用程序都是围绕执行任务进行管理的，任务是抽象，离散的工作单元，所以编写并发程序，首要工作就是提取和分解并行任务。 一旦任务被抽象出来，他们就可以交给并发编程平台去执行，同时在任务抽象还有另一个重要抽象，那就是生命周期，一个任务的开始，结束，返回结果，都是生命周期中重要的阶段。

那么编程平台必须提供有效安全的管理任务生命周期的API。 四、线程模型 线程模型是Java的本质模型，它无所不在，所以Java开发必须搞清楚底层线程调度细节，不搞清楚当然就会有struts1,struts2的原理搞不清楚的基本灾难（比如在struts2的action中塞入状态，把struts2的action配成单例）。

用线程来抽象并发编程，是比较低级别的抽象，所以难度就大一些，难度级别会根据我们的任务特点有以下几个类别 （1）任务非常独立，不共享，这是最理想的情况，编程压力为0。 (2)共享数据，压力开始增大，必须引入锁，Volatile变量，问题有活跃度和性能危险。

（3）状态依赖，压力再度增大，这时候我们基本上都是求助jdk 提供的同步工具。 五、任务执行 任务是一个抽象体，如果被抽象了出来，下一步就是交给编程平台去执行，在Java中，描述任务的一个基本接口是Runnable，可是这个抽象太有限了，它不能返回值和抛受检查异常，所以Jdk5。

0有另外一个高级抽象Callable。 任务的执行在Jdk中也是一个底级别的Thread，线程有好处，但是大量线程就有大大的坏处，所以如果任务量很多我们并不能就创建大量的线程去服务这些任务，那么Jdk5。

0在任务执行上做了抽象，将任务和任务执行隔离在接口背后，这样我们就可以引入比如线程池的技术来优化执行，优化线程的创建。 任务是有生命周期的，所以Jdk5。

0提供了Future这个对象来描述对象的生命周期，通过这个future可以取到任务的结果甚至取消任务。 六、锁 当然任务之间共享了数据，那么要保证数据的安全，必须提供一个锁机制来协调状态，锁让数据访问原子，但是引入了串行化，降低了并发度，锁是降低程序伸缩性的原罪，锁是引入上下文切换的主要原罪，锁是引入死锁，活锁，优先级倒置的绝对原罪，但是又不能没有锁，在Java中，锁是一个对象，锁提供原子和内存可见性，Volatile变量提供内存可见性不提供原子，原子变量提供可见性和原子，通过原子变量可以构建无锁算法和无锁数据结构，但是这需要高高手才可以办到。
5.Java高并发入门要怎么学习
1、如果不使用框架，纯原生Java编写，是需要了解Java并发编程的，主要就是学习Doug Lea开发的那个java.util.concurrent包下面的API;2、如果使用框架，那么我的理解，在代码层面确实不会需要太多的去关注并发问题，反而是由于高并发会给系统造成很大压力，要在缓存、数据库操作上要多加考虑。

3、但是即使是使用框架，在工作中还是会用到多线程，就拿常见的CRUD接口来说，比如一个非常耗时的save接口，有多耗时呢？我们假设整个save执行完要10分钟，所以，在save的时候，就需要采用异步的方式，也就是单独用一个线程去save，然后直接给前端返回200。
6.Java如何进行并发多连接socket编程呢
Java多个客户端同时连接服务端，在现实生活中用得比较多。

同时执行多项任务，第一想到的当然是多线程了。下面用多线程来实现并发多连接。

import java。。

*; import java。io。

*; public class ThreadServer extends Thread { private Socket client; public ThreadServer(Socket c) { this。 client=c; } public void run() { try { BufferedReader in=new BufferedReader(new InputStreamReader(client。

getInputStream())); PrintWriter out=new PrintWriter(client。 getOutputStream()); Mutil User but can't parallel while (true) { String str=in。

readLine(); System。out。

println(str); out。 println("has receive。

"); out。

flush(); if (str。equals("end")) break; } client。

close(); } catch (IOException ex) { } finally { } } public static void main(String[] args)throws IOException { ServerSocket server=new ServerSocket(8000); while (true) { transfer location change Single User or Multi User ThreadServer mu=new ThreadServer(server。 accept()); mu。

start(); } } }J。
7.如何掌握java多线程,高并发,大数据方面的技能
线程：同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器（PC），线程切换开销小。

（线程是cpu调度的最小单位）线程和进程一样分为五个阶段：创建、就绪、运行、阻塞、终止。多进程是指操作系统能同时运行多个任务（程序）。

多线程是指在同一程序中有多个顺序流在执行。在java中要想实现多线程，有两种手段，一种是继续Thread类，另外一种是实现Runable接口.（其实准确来讲，应该有三种，还有一种是实现Callable接口，并与Future、线程池结合使用。
8.java工程师需要掌握哪些知识
1.Core Java，就是Java基础、JDK的类库，很多童鞋都会说，JDK我懂，但是懂还不足够，知其然还要知其所以然，JDK的源代码写的非常好，要经常查看，对使用频繁的类，比如String， *** 类（List,Map,Set）等数据结构要知道它们的实现，不同的 *** 类有什么区别，然后才能知道在一个具体的场合下使用哪个 *** 类更适合、更高效，这些内容直接看源代码就OK了2.多线程并发编程，现在并发几乎是写服务端程序必须的技术，那对Java中的多线程就要有足够的熟悉，包括对象锁机制、synchronized关键字，concurrent包都要非常熟悉，这部分推荐你看看《Java并发编程实践》这本书，讲解的很详细3.I/O,Socket编程，首先要熟悉Java中Socket编程，以及I/O包，再深入下去就是Java NIO，再深入下去是操作系统底层的Socket实现，了解Windows和Linux中是怎么实现socket的4.JVM的一些知识，不需要熟悉，但是需要了解，这是Java的本质，可以说是Java的母体， 了解之后眼界会更宽阔，比如Java内存模型（会对理解Java锁、多线程有帮助）、字节码、JVM的模型、各种垃圾收集器以及选择、JVM的执行参数（优化JVM）等等，这些知识在《深入Java虚拟机》这本书中都有详尽的解释，或者去oracle网站上查看具体版本的JVM规范.5.一些常用的设计模式，比如单例、模板方法、代理、适配器等等，以及在Core Java和一些Java框架里的具体场景的实现，这个可能需要慢慢积累，先了解有哪些使用场景，见得多了，自己就自然而然会去用。

6.常用数据库（Oracle、MySQL等）、SQL语句以及一般的优化7.JavaWeb开发的框架，比如Spring、iBatis等框架，同样他们的原理才是最重要的，至少要知道他们的大致原理。8.其他一些有名的用的比较多的开源框架和包，ty网络框架，Apache mon的N多包，Google的Guava等等，也可以经常去Github上找一些代码看看。

暂时想到的就这么多吧，1-4条是Java基础，全部的这些知识没有一定的时间积累是很难搞懂的，但是了解了之后会对Java有个彻底的了解，5和6是需要学习的额外技术，7-8是都是基于1-4条的，正所谓万变不离其宗，前4条就是Java的灵魂所在，希望能对你有所帮助9.（补充）学会使用Git。如果你还在用SVN的话，赶紧投入Git的怀抱吧。
9.java 多线程的并发到底是什么意思
一、多线程1、操作系统有两个容易混淆的概念，进程和线程。

进程：一个计算机程序的运行实例，包含了需要执行的指令；有自己的独立地址空间，包含程序内容和数据；不同进程的地址空间是互相隔离的；进程拥有各种资源和状态信息，包括打开的文件、子进程和信号处理。线程：表示程序的执行流程，是CPU调度执行的基本单位；线程有自己的程序计数器、寄存器、堆栈和帧。

同一进程中的线程共用相同的地址空间，同时共享进进程锁拥有的内存和其他资源。2、Java标准库提供了进程和线程相关的API，进程主要包括表示进程的java.lang.Process类和创建进程的java.lang.ProcessBuilder类；表示线程的是java.lang.Thread类，在虚拟机启动之后，通常只有Java类的main方法这个普通线程运行，运行时可以创建和启动新的线程；还有一类守护线程（damon thread），守护线程在后台运行，提供程序运行时所需的服务。

当虚拟机中运行的所有线程都是守护线程时，虚拟机终止运行。3、线程间的可见性：一个线程对进程 *** 享的数据的修改，是否对另一个线程可见可见性问题：a、CPU采用时间片轮转等不同算法来对线程进行调度[java] view plainpublic class IdGenerator{ private int value = 0; public int getNext(){ return value++； } } 对于IdGenerator的getNext（)方法，在多线程下不能保证返回值是不重复的：各个线程之间相互竞争CPU时间来获取运行机会，CPU切换可能发生在执行间隙。

以上代码getNext（)的指令序列：CPU切换可能发生在7条指令之间，多个getNext的指令交织在一起。

④ java多线程机制中线程间可以共享相同的内存单元对还是错

java多线程机制中线程间可以共享相同的内存单元是对的。根据查询相关公开信息显示，同一进程的多个线程间可以共享相同的内存单元，并可利用这些共享单元来实现数据交换、实时通信和必要的同步操作。

⑤ java多线程共同操作同一个队列,怎么实现

以下是两个线程：

import java.util.*;

public class Thread_List_Operation {
//假设有这么一个队列
static List list = new LinkedList();

public static void main(String[] args) {
Thread t;
t = new Thread(new T1());
t.start();
t = new Thread(new T2());
t.start();

}

}

//线程T1,用来给list添加新元素
class T1 implements Runnable{

void getElemt(Object o){
Thread_List_Operation.list.add(o);
System.out.println(Thread.currentThread().getName() + "为队列添加了一个元素");
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
getElemt(new Integer(1));
}

}

}

//线程T2,用来给list添加新元素
class T2 implements Runnable{

void getElemt(Object o){
Thread_List_Operation.list.add(o);
System.out.println(Thread.currentThread().getName() + "为队列添加了一个元素");
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
getElemt(new Integer(1));
}

}

}

//结果（乱序）
Thread-0为队列添加了一个元素
Thread-1为队列添加了一个元素
Thread-0为队列添加了一个元素
Thread-1为队列添加了一个元素
Thread-1为队列添加了一个元素
Thread-1为队列添加了一个元素
Thread-1为队列添加了一个元素
Thread-1为队列添加了一个元素
Thread-1为队列添加了一个元素
Thread-1为队列添加了一个元素
Thread-1为队列添加了一个元素
Thread-1为队列添加了一个元素
Thread-0为队列添加了一个元素
Thread-0为队列添加了一个元素
Thread-0为队列添加了一个元素
Thread-0为队列添加了一个元素
Thread-0为队列添加了一个元素
Thread-0为队列添加了一个元素
Thread-0为队列添加了一个元素
Thread-0为队列添加了一个元素