Java并发编程之多线程会导致的问题

骑猪看日落 2023-07-10 15:36 11阅读 0赞

## 1. 线程安全问题 ##

### 1.1 什么是线程安全？ ###

*  某权威作者定义：“当多个线程访问同一个对象时，如果**不用考虑这些线程的调度**，也**不需要额外的同步**，调用这个对象的行为都可以获得正确的结果，那么这个对象时线程安全的“。
 *  通俗易懂的定义：当多个线程访问同一个对象时，**不需要做额外的任何处理，像单线程编程一样**，程序可以正常运行，就可以称为线程安全。

### 1.2 线程安全问题有哪些？ ###

1.  运行结果错误：a++多线程下出现结果错误
2.  活跃性问题：死锁、活锁、饥饿

#### 1.2.1 运行结果错误 ####

下面演示a++运行结果错误：

public class APlusPlus implements Runnable { 
    
        static int a = 0;
        @Override
        public void run() { 
            for (int j = 0; j < 10000; j++) { 
                a++;
            }
        }
    
        public static void main(String[] args) throws InterruptedException { 
            APlusPlus aPlusPlus = new APlusPlus();
            Thread t1 = new Thread(aPlusPlus);
            Thread t2 = new Thread(aPlusPlus);
            t1.start();
            t2.start();
            t1.join();
            t2.join();
            System.out.println(a);
        }
    }

11054

我们预计的结果是20000，最后结果比预计的少，因为a++，看上去是一个操作，实际上包含了三个动作：  
1. 读取a  
2. 将a加一  
3. 将a的值写入到内存中  
说明a++操作是不具备原子性的，因此需要对a++操作进行同步，保证同一时刻只有一个线程执行a++操作。

#### 1.2.2 活跃性问题：死锁、活锁、饥饿 ####

下面演示死锁问题：

public class DeadLock { 
        private static Object lockA = new Object();
        private static Object lockB = new Object();
    
        public static void main(String[] args) { 
            Thread t1 = new Thread(new Runnable() { 
                @Override
                public void run() { 
                    synchronized (lockA) { 
                        System.out.println(Thread.currentThread().getName() + "获取到lockA");
                        try { 
                            Thread.sleep(1000);
                        } catch (InterruptedException e) { 
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName() + "正在尝试获取lockB...");
                        synchronized (lockB) { 
                            System.out.println(Thread.currentThread().getName() + "获取到lockB");
                            try { 
                                Thread.sleep(1000);
                            } catch (InterruptedException e) { 
                                e.printStackTrace();
                            }
                        }
                    }
                }
            });
            Thread t2 = new Thread(new Runnable() { 
                @Override
                public void run() { 
                    synchronized (lockB) { 
                        System.out.println(Thread.currentThread().getName() + "获取到lockB");
                        try { 
                            Thread.sleep(1000);
                        } catch (InterruptedException e) { 
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName() + "正在尝试获取lockA...");
                        synchronized (lockA) { 
                            System.out.println(Thread.currentThread().getName() + "获取到lockA");
                            try { 
                                Thread.sleep(1000);
                            } catch (InterruptedException e) { 
                                e.printStackTrace();
                            }
                        }
                    }
                }
            });
            t1.start();
            t2.start();
        }
    }

由于t1获取到lockA，t2获取到lockB，t1和t2分别想获取lockB和lockA，由于双方都没有释放锁，所以t1和t2都进入到了死锁状态。

### 1.3 各种需要考虑线程安全的情况 ###

1.  访问共享变量，比如对象的属性、静态变量、共享缓存等；
2.  所有依赖顺序的操作，比如：读改写（原子性）、读取-检查-操作（内存可见性）；
3.  数据之间存在绑定关系；
4.  使用其他类的时候，比如使用HashMap就不是线程安全的；

## 2. 性能问题 ##

为什么多线程会带来性能问题？一共分为以下两个原因：

1.  上下文切换
2.  内存同步

## 2.1 上下文切换 ##

*  什么是上下文切换：进行一次上下文切换时，先挂起当前线程，然后把当前线程状态存在某处，以便线程切换回来知道执行到哪里了，这个线程状态包含当前线程执行的指令和位置，这个状态就是上下文。
 *  由于上下文切换也会使得CPU自身的一些缓存失效，相对而言，也降低了执行速度。
 *  何时会密集地导致上下文切换：抢锁、IO

## 2.2 内存同步 ##

*  由于JMM规定了主内存和线程内存，而线程内存会缓存数据，可以增加计算速度。由于在多线程编程时使用了synchronized、volatile关键字等，禁止了线程缓存，也禁止了指令重排序，编译器CPU等优化手段，使得是能只用主内存了，相对而言就降低了性能