java多线程小探

递增共享计数器

https://www6.software.ibm.com/developerworks/cn/education/java/j-threads/tutorial/j-threads-6-5.html

通常，如果正在保护一个基本变量（如一个整数），有时只使用 volatile 就可以侥幸过关。但是，如果变量的新值派生自以前的值，就必须使用同步。为什么？考虑这个类：

public class Counter {

private int counter = 0;

public int get() { return counter; }

public void set(int n) { counter = n; }

public void increment() {

set(get() + 1);

}

}

当我们要递增计数器时，会发生什么？请看 increment() 的代码。它很清楚，但不是线程安全的。如果两个线程试图同时执行 increment()，会发生什么？计数器也许会增加 1，也许增加 2。令人惊奇的是，把 counter 标记成 volatile 没有帮助，使 get() 和 set() 都变成 synchronized 也没有帮助。

设想计数器是零，而两个线程同时执行递增操作代码。这两个线程会调用 Counter.get()，并且看到计数器是零。现在两个线程都对它加一，然后调用 Counter.set()。如果我们的计时不太凑巧，那么这两个线程都看不到对方的更新，即使 counter 是 volatile，或者 get() 和 set() 是 synchronized。现在，即使计数器递增了两次，得到的值也许只是一，而不是二。

要使递增操作正确运行，不仅 get() 和 set() 必须是 synchronized，而且 increment() 也必需是 synchronized！否则，调用 increment() 的线程可能会中断另一个调用 increment() 的线程。如果您不走运，最终结果将会是计数器只增加了一次，不是两次。同步 increment() 防止了这种情况的发生，因为整个递增操作是原子的。

当循环遍历 Vector 的元素时，同样如此。即使同步了 Vector 的方法，但在循环遍历时，Vector 的内容仍然会更改。如果要确保 Vector 的内容在循环遍历时不更改，必须同步整个代码块。

=======================================================================================================

不变性和 final 字段

许多 Java 类，包括 String、Integer 和 BigDecimal，都是不可改变的：一旦构造之后，它们的状态就永远不会更改。如果某个类的所有字段都被声明成 final，那么这个类就是不可改变的。（实际上，许多不可改变的类都有非 final 字段，用于高速缓存以前计算的方法结果，如 String.hashCode()，但调用者看不到这些字段。）

不可改变的类使并发编程变得非常简单。因为不能更改它们的字段，所以就不需要担心把状态的更改从一个线程传递到另一个线程。在正确构造了对象之后，可以把它看作是常量。

同样，final 字段对于线程也更友好。因为 final 字段在初始化之后，它们的值就不能更改，所以当在线程之间共享 final 字段时，不需要担心同步访问。

=======================================================================================================

什么时候不需要同步

在某些情况中，您不必用同步来将数据从一个线程传递到另一个，因为 JVM 已经隐含地为您执行同步。这些情况包括：

由静态初始化器（在静态字段上或 static{} 块中的初始化器）初始化数据时

访问 final 字段时

在创建线程之前创建对象时

线程可以看见它将要处理的对象时

=======================================================================================================

同步准则

当编写 synchronized 块时，有几个简单的准则可以遵循，这些准则在避免死锁和性能危险的风险方面大有帮助：

使代码块保持简短。Synchronized 块应该简短 ― 在保证相关数据操作的完整性的同时，尽量简短。把不随线程变化的预处理和后处理移出 synchronized 块。

不要阻塞。不要在 synchronized 块或方法中调用可能引起阻塞的方法，如 InputStream.read()。

在持有锁的时候，不要对其它对象调用方法。这听起来可能有些极端，但它消除了最常见的死锁源头。

=======================================================================================================

每个 Java 程序都使用线程，不论您知道与否。如果您正在使用 Java UI 工具箱（AWT 或 Swing）、Java Servlet、RMI、JavaServer Pages 或 Enterprise JavaBeans 技术，您可能没有意识到您正在使用线程。

在许多情况中，您可能想要显式地使用线程以提高程序的性能、响应速度或组织。这些情况包括：

在执行耗时较长的任务时，使用户界面的响应速度更快

利用多处理器系统以并行处理多个任务

简化仿真或基于代理的系统的建模

执行异步或后台处理

虽然线程 API 很简单，但编写线程安全的程序并不容易。在线程之间共享变量时，必须非常小心，以确保正确同步了对它们的读写访问。当写一个可能接下来由另一个线程读取的变量，或者读取可能由另一个线程写过的变量时，必须使用同步以确保对数据的更改在线程之间是可见的。

当使用同步保护共享变量时，必须确保不仅使用了同步，而且读取器和写入器在同一个监控器上同步。而且，如果依赖对象的状态在多个操作中保持相同，或者依赖多个变量互相保持一致（或者，与它们过去的值一致），那么必须使用同步来强制实现这一点。但简单地同步一个类中的每一个方法并不能使它变成线程安全的 ― 只会使它更容易发生死锁。

=======================================================================================================

例子：

（一）即时显示当前时间：

import java.util.*;

import java.text.*;

import java.applet.Applet;

import java.awt.Graphics;

public class Clock extends Applet implements Runnable {

Thread clockThread;

public void start() {

if (clockThread == null) {

clockThread = new Thread(this, "Clock");

clockThread.start();

}

}

public void run() {

while (clockThread != null) {

repaint();

try {

clockThread.sleep(1000);

} catch (InterruptedException e) {

}

}

}

public void paint(Graphics g) {

//Date now = new Date();

// now.getHours()+now.getMinutes()+now.getSeconds()(过时的方法)

DateFormat df = new SimpleDateFormat("EEEE-MMMM-dd-yyyy HH:mm:ss");

Calendar c = Calendar.getInstance();

g.drawString(df.format(c.getTime()), 5, 10);

g.drawString(DateFormat.getTimeInstance().format(c.getTime()), 5, 30);

g.drawString(DateFormat.getTimeInstance(DateFormat.LONG, Locale.CHINA)

.format(c.getTime()), 5, 50);

g.drawString(DateFormat.getInstance().format(c.getTime()), 5, 70);

g.drawString(DateFormat.getDateTimeInstance(DateFormat.FULL,

DateFormat.FULL).format(c.getTime()), 5, 90);

g.drawString(DateFormat.getDateTimeInstance().format(c.getTime()), 5,

110);

}

public void stop() {

clockThread.stop();

clockThread = null;

}

public static void main(String[] args) {

new Clock().start();

}

}



（二）生产者、消费者问题

class CubbyHole {

private int seq;

private boolean available = false; // 信号量

/**

* 用synchronized来标识的区域或方法即为对象互斥锁锁住的部分。

*

* 如果一个程序内有两个或以上的方法使用synchronized标志，

*

* 则它们 在同一个对象互斥锁管理之下。

*

* 一般情况下，都使用synchronized关键字在方法的层次上实现对共享资源操作的同步，

*

* 很少使用volatile关键字声明共享变量。

*/

public synchronized int get() {

while (available == false) {

try {

// wait()方法的作用是让当前线程释放其所持有的对象互斥锁，进入wait队列（等待队列）

wait();

// waits for notify() call from Producer

} catch (InterruptedException e) {

}

}

available = false;

// notify()/notifyAll()方法的作用是唤醒一个或所有正在等待队列中等待的线程，

// 并将它（们）移入等待同一个对象互斥锁的队列。

notify();

// 需要指出的是： notify()/notifyAll()方法和wait()方

// 法都只能在被声明为synchronized的方法或代码段中调用。

return seq;

}

public synchronized void put(int value) {

while (available == true) {

try {

wait();

// waits for notify() call from consumer

} catch (InterruptedException e) {

}

}

seq = value;

available = true;

notify();

}

}

class Producer extends Thread {

private CubbyHole cubbyhole;

private int number;

public Producer(CubbyHole c, int number) {

cubbyhole = c;

this.number = number;

}

public void run() {

for (int i = 0; i < 10; i++) {

cubbyhole.put(i);

System.out.println("Producer @" + this.number + " put: " + i);

try {

sleep((int) (Math.random() * 100));

} catch (InterruptedException e) {

}

}

}

}

class Consumer extends Thread {

private CubbyHole cubbyhole;

private int number;

public Consumer(CubbyHole c, int number) {

cubbyhole = c;

this.number = number;

}

public void run() {

int value = 0;

for (int i = 0; i < 10; i++) {

value = cubbyhole.get();

System.out.println("Consumer #" + this.number + " got: " + value);

}

}

}

public class ProducerConsumerTest {

public static void main(String args[]) {

CubbyHole c = new CubbyHole();

Producer p1 = new Producer(c, 1);

Consumer c1 = new Consumer(c, 1);

//Consumer c2 = new Consumer(c, 2);

p1.setPriority(Thread.MAX_PRIORITY);

c1.setPriority(Thread.NORM_PRIORITY);

//c2.setPriority(Thread.NORM_PRIORITY);

p1.start();

c1.start();

//c2.start();

}

}

输出结果：

Producer @1 put: 0

Consumer #1 got: 0

Producer @1 put: 1

Consumer #1 got: 1

Producer @1 put: 2

Consumer #1 got: 2

Producer @1 put: 3

Consumer #1 got: 3

Producer @1 put: 4

Consumer #1 got: 4

Producer @1 put: 5

Consumer #1 got: 5

Producer @1 put: 6

Consumer #1 got: 6

Producer @1 put: 7

Consumer #1 got: 7

Producer @1 put: 8

Consumer #1 got: 8

Producer @1 put: 9

Consumer #1 got: 9

收藏于 2009-11-24