Java基础——多线程的安全问题

首先用一个例子来引入，多线程中常见的线程安全问题：

我们自定义一个线程类实现Runnable接口：

package com.flyingduck.thread;public class PrintThread implements Runnable {private String str;public PrintThread(String str) {this.str = str;}@Overridepublic void run() {while (true) {try {Thread.sleep(500);} catch (InterruptedException e) {e.printStackTrace();}printString(str);}}private void printString(String str) {for (int i = 0; i < str.length(); i++) {System.out.print(str.charAt(i));}System.out.println();}}

线程用于逐个字符打印str字符串；

package com.flyingduck.thread;public class TraditionalThread {public static void main(String[] args) {PrintThread target1 = new PrintThread("AAA-BBB");PrintThread target2 = new PrintThread("CCC-DDD");new Thread(target1).start();new Thread(target2).start();}}

我们启动了两个线程打印不同的字符串。按照正常来说，我们应该每次都会打印完整的“AAA-BBB”“CCC-DDD”字符串，但是结果却是：

AAA-BBBCCC-DDDACCC-DDDAA-BBBCAAA-BBBCC-DDDAAA-BBBCCC-DDDACCC-DDDAA-BBBCCC-DDDAAA-BBBCACC-DDDAA-BBBACAA-BBB

之所以会发生这种情况是因为，在多个线程争夺CUP的使用权的时候发生了不安全的事情：当线程1取得CPU使用权打印到一部分时，线程2抢到了CPU的使用权，这时开始打印线程2中的数据，就出现了上面的结果。为了解决这样的问题，我们必须保证在执行类似于打印字符串这样的写操作时，一定要保证它能够执行完（类似于数据库中的一个事务），才让出CPU的使用权。

Java中使用线程同步解决这样的问题：

package com.flyingduck.thread;public class PrintThread implements Runnable {private String str;private static Object lock = new Object();public PrintThread(String str) {this.str = str;}@Overridepublic void run() {while (true) {try {Thread.sleep(500);} catch (InterruptedException e) {e.printStackTrace();}synchronized (lock) { //为什么不适用str作为锁呢?printString(str);}}}private void printString(String str) {for (int i = 0; i < str.length(); i++) {System.out.print(str.charAt(i));}System.out.println();}}

这里将打印的操作放入同步代码块中（synchronized关键字）；代码块需要一个对象作为同步锁。这里为什么不直接用str对象作为锁呢，而要用一个静态的对象。原因是：既然要起到锁的作用，就必须保证需要保持同步的线程只共享一个锁，虽然在类中咋一看，觉得str只有一个，但是仔细想一下发现，并不是这样的，因为每次创建runnable对象的时候都会传进来一个新的对象（“AAA-BBB”、“CCC-DDD”就充当了不同的两把锁，在这里同步就变得没有意义了）。因为静态的对象是属于类的，而不是一个对象的，所以它可以起到同步锁的作用。

另外的解决办法：

package com.flyingduck.thread;public class PrintThread implements Runnable {private String str;private static Object lock = new Object();public PrintThread(String str) {this.str = str;}@Overridepublic void run() {while (true) {try {Thread.sleep(500);} catch (InterruptedException e) {e.printStackTrace();}//synchronized (lock) { //为什么不适用str作为锁呢?printString(str);//}}}private synchronized void printString(String str) {for (int i = 0; i < str.length(); i++) {System.out.print(str.charAt(i));}System.out.println();}}

将普通方法变成同步的可不可以呢？ 当然不行，因为普通非静态的同步方法使用的同步锁对象是：this。大家仔细想想，我们创建了两个runnable的实例，当然他们的this就是他们各自的this了，这就变成和使用str对象作为同步锁一样的性质了。

当然我们可以将这个方法变成静态的：

package com.flyingduck.thread;public class PrintThread implements Runnable {private String str;private static Object lock = new Object();public PrintThread(String str) {this.str = str;}@Overridepublic void run() {while (true) {try {Thread.sleep(500);} catch (InterruptedException e) {e.printStackTrace();}//synchronized (lock) { //为什么不适用str作为锁呢?printString(str);//}}}private synchronized static void printString(String str) {for (int i = 0; i < str.length(); i++) {System.out.print(str.charAt(i));}System.out.println();}}

这样就可以解决问题了。（原因不难想，是因为静态的方法使用的同步锁对象是类的字节码 也就是 class对象）