在Java多线程中我会重点总结五个如下的技术点：
1、非线程安全是如何出现的
2、synchronized对象监视器为Objec时的使用
3、synchronized对象监视器为Class时的使用
4、关键字volatile的主要作用
今天我先说一说第一个问题，非线程安全是如何出现的。“非线程安全”会在多个线程对同一个对象中的实例变量进行并发访问的时候发生，产生的后果就是“脏读”，也就是读取到的数其实是已经被更改过的了。下面我分别实现“线程安全”和“非线程安全”的两个例子，让大家来体会一下对实例变量更改是怎么发生的。但是多线程的结果会有很多输出结果，希望大家还是亲自敲代码才会理解的更深一些，下面先说一下“线程安全”的例子。如下：
public static void main(String[] args) {
PrivateNum num = new PrivateNum();
MyThreadA a = new MyThreadA(num);
MyThreadB b = new MyThreadB(num);
a.start();
b.start();
}
public static class PrivateNum {
public void addnum(String name) {
//重点是num变量是addnum这个方法的局部变量
int num = 0;
try {
if ("a".equals(name)) {
num = 100;
System.out.println("a ser over!");
Thread.sleep(2000);
} else {
num = 200;
System.out.println("b set over!");
}
System.out.println("线程" + name + "的num=" + num);
} catch (Exception e) {
e.printStackTrace();
}
}
}
public static class MyThreadA extends Thread {
private PrivateNum privateNum;
public MyThreadA(PrivateNum privateNum) {
super();
this.privateNum = privateNum;
}
@Override
public void run() {
super.run();
privateNum.addnum("a");
}
}
public static class MyThreadB extends Thread {
private PrivateNum privateNum;
public MyThreadB(PrivateNum privateNum) {
super();
this.privateNum = privateNum;
}
@Override
public void run() {
super.run();
privateNum.addnum("b");
}
}
运行结果如下：无论输出顺序是怎样的，但是这段代码执行的结果一定是线程安全的，原因就在于num的这个变量是addnum方法私有的局部变量，PrivateNum的对象访问不到num这个变量，所以就没有多num这个变量改变的这个说，自然就不会出现“非线程安全”的状况。
下面在说一个“非线程安全”的例子，如 public static void main(String[] args) { GetNum num = new GetNum();
ThreadA a = new ThreadA(num);
a.start();
ThreadB b = new ThreadB(num);
b.start();
}
public static class GetNum {
//之所以会出现“非线程安全”的现象，是因为num这个变量是GetNUm类的全局变量
private int num = 0;
public void getNum(String name) {
try {
if ("a".equals(name)) {
num = 100;
System.out.println("a set over");
执行到这里的时候，线程a休眠了，此时num=100，接着线程b执行了，执行的结果把num重新赋值为num=200了，线程b执行完了之后，休眠的2000毫秒也过了，
线程a会接着执行，而不是重新执行，所以这个时候的num仍然是200，发生了“非线程安全问题”
Thread.sleep(2000);
} else {
num = 200;
System.out.println("b set over");
}
System.out.println("线程" + name + "的num=" + num);
} catch (Exception e) {
e.printStackTrace();
}
}
}
public static class ThreadA extends Thread {
private GetNum num;
public ThreadA(GetNum num) {
super();
this.num = num;
}
@Override
public void run() {
super.run();
num.getNum("a");
}
}
public static class ThreadB extends Thread {
private GetNum num;
public ThreadB(GetNum num) {
super();
this.num = num;
}
@Override
public void run() {
super.run();
num.getNum("b");
}
}
运行结果如下：线程a的num=200，出现了“非线程安全”的现象了，出现的原因就是线程a和线程b都对PrivateNum类下的num对象作出改变了，具体的改变过程在程序中已经分析过了。而解决“非线程安全”的问题就是同步，下面的几节会说。
在上述例子中，是在给num赋值的时候出现没有保持线程同步，出现“脏读”，但是在取值的时候也可能出现“脏读”，发生“脏读”是因为在读取实例变量时，这个值已经被修改过了。下面看一个取值发生“脏读”的例子，如下：
public static void main(String[] args) {
try {
PublicVar publicVar = new PublicVar();
ThreadA threadA = new ThreadA(publicVar);
threadA.start();
// 睡眠时间影响输出结果
Thread.sleep(200);
publicVar.getValue();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static class PublicVar {
public String name = "A";
public String password = "a";
synchronized public void setValues(String name, String password) {
try {
this.name = name;
Thread.sleep(5000);
this.password = password;
System.out.println("setValue method thread name="
+ Thread.currentThread().getName());
System.out.println("setValue name=" + name);
System.out.println("setValue password=" + password);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public void getValue() {
System.out.println("getValue method thread name="
+ Thread.currentThread().getName());
System.out.println("getValue name=" + name);
System.out.println("getValue password=" + password);
}
}
public static class ThreadA extends Thread {
private PublicVar publicVar;
public ThreadA(PublicVar publicVar) {
super();
this.publicVar = publicVar;
}
@Override
public void run() {
super.run();
publicVar.setValues("B", "b");
}
}
运行结果如下：这里边出现“脏读”是因为setValues()方法没有运行完，但是name已经赋值为B，password还没来得赋值就休眠了5000毫秒，所以是main线程先输出的name="B",password="a"。等到5000毫秒到了，子线程又在原来被打断的地方接着运行了，也就是开始给password赋值为b，所以第二次是Thread-0线程输出name="B",password="b"。这里我说过主线程的休眠时间会影响输出结果，如果主线程的休眠时间比子线程的时间长，能够保证子线程执行完，就不会发生“脏读”的情况了。解决脏读就要通过给getValue()方法添加synchronized关键字。
