1.线程安全问题
多个线程同时运行，线程调度由操作系统决定，程序本身无法决定。
如果多个线程同时读写共享变量，就可能出现问题。
假设有AddThread和DecThread，它们分别对同一个共享变量做加和减运算LOOP次，最终结果应该是0。但某些时候比如LOOP为10000时，结果是错误的。
class AddThread extends Thread{
public void run(){
for(int i=0;i<Main.LOOP;i++){
Main.count += 1;
}
}
}
class DecThread extends Thread{
public void run(){
for(int i=0;i<Main.LOOP;i++){
Main.count -= 1;
}
}
}
public class Main {
final static int LOOP = 10000;
public static int count = 0;
public static void main(String[] args) throws InterruptedException{
Thread t1 = new AddThread();
Thread t2 = new DecThread();
t1.start();
t2.start();
//等待这两个线程执行结束
t1.join();
t2.join();
System.out.println(count);
}
}
## 2.原子操作
* 因此对共享变量进行写入时，必须保证是原子操作
* 原子操作是指不能被中断的一个或一系列操作
当执行 n = n +1时，编译器会把它编译为3条字节码指令，分别是ILOAD, IADD, ISTORE。所以对于这个简单的赋值语句，它并不是一个原子操作，这就可能导致两个线程在执行这条语句的时候，会出现问题。
假设1：n=100，Thread1执行语句n为101，Thread2再执行n为102。
假设2：Thread1刚执行完ILOAD指令，就被操作系统暂停了，然后Thread2调度执行，结果n变成了101，此后Thread1再度被操作系统调度执行，结果也是101。即n+1的指令被2个线程调用了2次，最终只加了1.
所以我们要保证当Thread1执行时，Thread2不能执行，直到Thread1执行完毕，Thread2才能开始执行。这样运行的结果就是正确的。
要实现这个效果，就要对ILOAD之前和ISTORE之后进行加锁和解锁。
3.同步代码块
Java使用synchronized对一个对象进行加锁：
- 为了保证一系列操作作为原子操作，必须保证一系列操作过程中不被其他线程执行
synchronized (lock){
n=n+1;
}
当一个线程想要执行synchronized语句块时，必须首先获得指定对象的锁，这个对象就是synchronized括号里的对象，然后线程再执行synchronized语句块，执行结束以后释放锁。
在执行synchronized语句块时，如果Thread1执行到任何语句时，被操作系统中断。其他线程如Thread2因为无法获取lock对象的锁，从而导致Thread2无法进入synchronized语句块，Thread2就必须等待，直到Thread1再次被调用，并执行完synchronized语句块释放了锁，Thread2才能获得lock对象锁，进入synchronized语句块。
synchronized保证了代码块和任意时刻最多只有一个线程能执行。
- 因为一个对象的锁只能被一个线程获得，其他线程必须等待。
synchronized的问题：
- 性能下降。因为synchronized代码块无法并发执行，所以性能会下降。此外加锁和解锁都会消耗一定的时间，所以synchronized会降低程序的执行效率。
如何使用synchronized：
- 1.找出修改共享变量的线程代码块
- 2.选择一个实例作为锁
- 3.使用synchronized(lock Object){...}
注意：
- 对于同一个变量的修改，必须要获取同一个锁，如果2个线程获取的是不同的锁，它们是没有办法进行同步的。
- 不用担心异常。无论有无异常，在synchronized结束时都会释放锁。
class AddThread extends Thread{
public void run(){
for(int i=0;i<Main.LOOP;i++){
synchronized (Main.LOCK) {
Main.count += 1;
}
}
}
}
class DecThread extends Thread{
public void run(){
for(int i=0;i<Main.LOOP;i++){
synchronized (Main.LOCK) {//对于同一个变量的修改，要使用同一个锁
Main.count -= 1;
}//无论有无异常，都会在此释放锁
}
}
}
public class Main {
final static int LOOP = 10000;
public static int count = 0;
public static final Object LOCK = new Object();
public static void main(String[] args) throws InterruptedException{
Thread t1 = new AddThread();
Thread t2 = new DecThread();
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(count);
}
}
4.JVM的原子操作
JVM定义了几种原子操作：
- 基本类型（long和double除外）赋值
- 引用类型赋值
注意：
- 原子操作时不需要同步的。
- 可以把非原子操作变为原子操作
- 局部变量不需要同步
//原子操作不需要同步
public void set(int m){
synchronized (obj){
this.value = m;
}
}
//->
public void set(int m){
this.value = m;
}
//对2个int类型进行赋值，它不是一个原子操作。但可以先构造一个int数组，然后利用引用类型赋值，把它变成1个原子操作。
class Pair{
int first;
int last;
public void set(int first,int last){
synchronized (this){
this.first = first;
this.last = last;
}
}
}
//->
class Pair{
int[] pair;
public void set(int first,int last){
int[] ps = new int[]{first,last};
this.pair = ps;
}
}
//a，b，s1，s2，r都是局部变量，各个线程的局部变量是完全独立的，互不影响，所以这个方法不需要同步。
public int avg(int a, int b){
int s1 = a*a + b*b;
int s2 = a + b;
int r = s1/s2;
return r;
}
5.总结：
- 多线程同时修改变量，会造成逻辑错误
* 需要通过synchronized同步
* 同步的本质就是给指定对象加锁
* 注意加锁对象必须是同一个实例 - 对JVM定义的单个原子操作不需要同步