Java并发：并发基础（二）

青旅半醒 2022-01-31 06:55 243阅读 0赞

## 一：并发与并行 ##

**并发：** 在同一时间段内多个任务同时在执行，并且没有执行结束。  
CPU是通过时间片的方式来进行控制线程的运行，单位时间内只有一个线程在运行，其他线程都处于挂起状态，线程轮流获得CPU的使用权限。  
**并行：** 在单位时间内多个任务同时执行。  
一个任务分为多段，交由不同的CPU同时执行，执行完成后合并输出结果。

## 二：内存可见性 ##

内存可见性：简而言之，线程A正在使用变量A，线程B修改变量A的值，线程A却不知道。  
**例子：**

public class ThreadSafeTest { 
        private static Integer i=0;
    
        public static void main(String[] args) throws Exception { 
            new Thread(() -> { 
                System.out.println("线程A开始");
                while (i==0) { };
                System.out.println("线程A结束");
            }).start();
            Thread.sleep(100);
            new Thread(() -> { 
                System.out.println("线程B结束");
                i++;
                System.out.println("线程B结束");
            }).start();
        }
    }

线程B修改变量i的值，线程A并不知情，还在一直运行。  
**原因：**  
如下图，每个线程都会有自己的工作内存，线程寻求变量会先去自己的工作内存中寻找，没有命中才会去主内存中复制。线程A，线程B都对变量i有需求，都会将变量i的副本复制到自己的工作内存中，等待使用。线程A先执行，进入死循环，由于工作内存中存在变量i，所以会无法打破循环。线程B再执行完方法之后，更新递增后的值到主内存中，却无法通知线程A，变量i的值已经修改。  
![线程工作内存模型][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDA4NTM1_size_16_color_FFFFFF_t_70]  
CPU系统架构：  
![CPU系统架构][CPU]  
控制器包含一组寄存器和操作控制器，运算器执行算术逻辑运算，一级缓存为CPU私有，二级缓存为所有CPU共享。线程的工作内存可能是寄存器，一级缓存，二级缓存。

## 三：synchronized和volatile ##

1.  synchronized关键字

*  synchronized代码块

public class SynchronizedTest { 
        private static Object object = new Object();
    
        public static void main(String[] args) { 
            new Thread(() -> { 
                System.out.println("线程A获取锁");
                synchronized (object){ 
                    try { 
    
                        Thread.sleep(3000l);
                    }catch (Exception e){ }
                }
                System.out.println("线程A释放锁");
            }).start();
    
            new Thread(() -> { 
                System.out.println("线程B正在等待锁");
                synchronized (object){ 
                    try { 
                        Thread.sleep(100l);
                    }catch (Exception e){ }
                }
                System.out.println("线程B释放锁");
            }).start();
        }
    }

*  synchronized方法

public class SynchronizedTest { 
        private static Object object = new Object();
    
        public static void main(String[] args) throws Exception  { 
            SynTest synTest = new SynTest();
            new Thread(() -> { 
                System.out.println(Thread.currentThread().getName()+"即将占用锁");
                synTest.getLock(Thread.currentThread());
                System.out.println(Thread.currentThread().getName()+"释放锁");
            }).start();
            Thread.sleep(200l);
            new Thread(() -> { 
                System.out.println(Thread.currentThread().getName()+"等待锁");
                synTest.getLock(Thread.currentThread());
                System.out.println(Thread.currentThread().getName()+"释放锁");
            }).start();
        }
    }
    
    class SynTest { 
        public synchronized  void getLock(Thread thread) { 
            System.out.println(thread.getName() + "正在用锁");
            try { 
                Thread.sleep(5000l);
            }catch (Exception e){ }
        }
    }

两种方法说明synchronized修改的代码块或者方法，synchronized修饰的资源只能用于一条线程使用，其他需要的线程只能阻塞，挂起等待资源。  
这是因为Java有一种内部锁机制，可以将每个对象当做一个同步锁来进行使用，也可以称之为监视器锁，synchronized修改的代码块或者方法在使用时候会获取内部锁，在退出同步代码块或者方法或者wait()方法会释放锁，而且内部锁是一个排它锁，非常自私，在自己使用完成之前只能自己使用。  
阻塞线程需要线程从用户态到内核态来操作阻塞操作，非常耗时，使用Synchronized会频繁导致上下文切换。  
synchronized关键字从线程结果来看，当进入同步代码块或者同步方法时，会将线程的工作内存清空，直接从主内存读取数据，当退出时，会将共享变量刷新到线程的工作内存中。  
2. volatile关键字

public class ThreadSafeTest { 
        private static volatile Integer i=0;
    
        public static void main(String[] args) throws Exception { 
            new Thread(() -> { 
                System.out.println("线程A开始");
                while (i==0) { };
                System.out.println("线程A结束");
            }).start();
            Thread.sleep(100);
            new Thread(() -> { 
                System.out.println("线程B结束");
                i++;
                System.out.println("线程B结束");
            }).start();
        }
    }

volatile关键字修饰的变量，再写入变量时不会把值存在线程的工作内存，而是会把值直接刷新都内存，在获取值的时候，也会直接从主内存种获取，也就是直接操作主内存，不关心线程自身的工作内存，保证可见性问题，但无法保证操作的原子性。

## 4:原子性操作 ##

原子性操作，在进行一系列操作时，要不全部成功，要不全部不执行，不存在只执行了一半情况。

public class ThreadNotSafeTest { 
        public static Integer i = 0;
    
        public static void main(String[] args) { 
            new Thread(() -> { 
                for (int j = 0; j < 10000; j++) { 
                    i++;
                }
                System.out.println(i);
            }).start();
         /* try { Thread.sleep(5000L); }catch (Exception e){} */
            new Thread(() -> { 
                for (int j = 0; j < 10000; j++) { 
                    i++;
                }
                System.out.println(i);
            }).start();
        }
    }

上述就是原子可见性的反例，预期结果为20000，结果什么都有可能，原因是内存可见性和原子性  
**解决方法：**

1.  synchronized关键字  
    synchronized能很好解决内存可见性和原子性问题，但是synchronized是一个排它锁，会增加线程上下文切换的能耗，不是优质选择。
2.  Atomic原子类  
    **CAS操作：** Compare and swap，因为synchronized的锁会增加线程上下文切换和重新调度开销，volatile只能解决可见性问题，不能解决操作原子性问题。

public final native boolean compareAndSwapInt(Object object, long valueOffset, 
    												int excepct, int update);

object：对象内存地址 valueOffset：变量内存偏移 excepct：期望值 update：修改值  
**ABA问题：**  
现有线程A，线程B，对象C，C中有变量D值为d。两个线程都会用CAS修改对象C中的变量D。  
线程A先去获取对象C中的变量D，然后线程B获取对象C中的变量D并修改值为e，随后线程B又将变量D的值修改回来为d，接着线程A继续操作，但这里对象C已经可能不是原来的对象C了，只是外壳一样，不代表内部是否发生改变。  
**解决：** ABA问题，可使用JDK的并发包中的AtomicStampedReference类。

## 5：Unsafe类 ##

1.  获取Unsafe类的实例  
    看到Unsafe类中有getUnsafe()方法，返回一个unsafe实例，期望结果为返回一个unsafe实例。

public class UnsafeTest { 
            public static void main(String[] args) { 
               Unsafe unsafe  = Unsafe.getUnsafe();
               System.out.println("its Ok!");
            }
    }

结果：报错，权限安全异常-SecurityException  
![Unsafe实例创建][Unsafe]原因：类加载器的问题  
![JVM类加载器][JVM]  
Bootstrap 启动类加载器：负责加载<JAVA\_HOME>/lib目录下 或 -Xbootclasspath 指定路径下的jar包，例如rt.jar.

Extension 扩展类加载器：负责加载<JAVA\_HOME>/lib/ext目录下的jar包或 -Djava.ext.dirs 指定目录下的jar包,例如xunec.jar。

Application 应用程序类加载器：这个加载器由sum.misc.Launcher$App-ClassLoader类实现，一般称呼为系统加载器， 负责加载用户路径（ClassPath）上指定的类库，如果用户没有自己自定义加载器，一般为默认的类加载器.

自定义类加载器：在程序运行期间, 通过java.lang.ClassLoader的子类动态加载class文件, 体现java动态实时类装入特性.

双亲委派模型：每个加载器在收到加载请求的时候，都会向上传达加载请求，直到Bootstrap启动类加载器，父类加载不了类才会下放加载请求。

报错原因-getUnsafe()方法源码：

public static Unsafe getUnsafe() { 
        	//获取UnsafeTest的class对象
            Class var0 = Reflection.getCallerClass();
            //是不是默认的类加载器
            if (!VM.isSystemDomainLoader(var0.getClassLoader())) { 
                throw new SecurityException("Unsafe");
            } else { 
                return theUnsafe;
            }
        }

验证UnsafeTest的类加载器：证明加载UnsafeTest的加载器为Application类加载器

public class UnsafeTest { 
            public static void main(String[] args) { 
                  Class<UnsafeTest> unsafeTestClass = UnsafeTest.class;
          		  System.out.println(unsafeTestClass.getClassLoader());
            }
    }

> sun.misc.Launcher$AppClassLoader@18b4aac2

1.  调用Unsafe方法  
    不能正常获取Unsafe方法，那么只能通过黑科技放射来进行方法调用了。

public class UnsafeTest { 
        public  long state = 0;
    
        public static void main(String[] args) { 
            UnsafeTest unsafeTest = new UnsafeTest();
            try { 
                Field field = Unsafe.class.getDeclaredField("theUnsafe");
                field.setAccessible(true);
                Unsafe unsafe = (Unsafe) field.get(null);
                long offset = unsafe.objectFieldOffset(UnsafeTest.class.getDeclaredField("state"));
                boolean b = unsafe.compareAndSwapInt(unsafeTest, offset, 0, 1);
                System.out.println(b);
            } catch (Exception e) { 
    
            }
        }
    
    }

## 六：指令重排 ##

Java内存结构模型允许编译器和处理器对指令进行重排序以提高运行性能，并且只会对不存在数据依赖性的指令重排序。  
例如：

int a = 1;(1)
            int b = 2;(2)
            int c = a+b;(3)

在单线程中，可能是1号指令先执行，也可能是2号指令先执行，3号指令由于依赖于1号，2号指令的结果，最后执行。在单线程中，不存在指令重排带来的问题。  
问题出在多线程：

public class ThreadxTest { 
        public static boolean boo = false;
        public static Integer num = 0;
        
    }
    class MyTHreadOne extends Thread{ 
        @Override
        public void run() { 
            while (!Thread.currentThread().isInterrupted()){ 
                if(ThreadxTest.boo){ (1)
                   System.out.println(ThreadxTest.num);(2) 
                }
            }
        }
    }
    class MyTHreadTwo extends Thread{ 
        @Override
        public void run() { 
            ThreadxTest.num = 100;(3)
            ThreadxTest.boo= true;(4)
        }
    }

由于两个线程没有数据依赖关系，在线程Two中，指令3和指令4都可能先执行，在不考虑可见性问题下，线程one输出的结果可能为0或者100.  
**解决方法：** volatile修饰变量即可，volatile可以解决可见性问题和指令重排问题。

## 七：伪共享 ##

1.  什么是伪共享  
    ![CPU结构][CPU 1]  
    为了解决计算机和CPU之间的运行速度问题，在CPU与主内存之间添加一级或者多级高速缓冲储存器（Cache）。Cache一般集成在CPU内部。  
    Cache的基本单位为Cache行，当CPU访问某个变量，会先去缓存中看看有没有，没有再去主内存中获取，每次加载需求变量开始一个Cache行大小的内存数据到缓存中。且缓存行每次只供一个线程访问。  
    ![线程调用机制][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDA4NTM1_size_16_color_FFFFFF_t_70 1]  
    假设现在两个CPU，一级缓存中都存在共享变量X,Y,Z，且X,Y,Z都在一个缓存行中。再假设CPU1有线程A，CPU2有线程B，且线程A先运行。线程A对变量X进行写入修改，在缓存一致性协议下，会通知其他CPU，X已经修改，X所在的缓存行需要失效。线程B在访问变量Y的时候需要重新从主内存中加载到缓存中。
2.  如何解决  
    产生伪共享的主要原因为：多个变量放入一个缓存行中，通过填充字段可解决。JDK 8 提供一个sum.misc.Contended注解来解决伪共享问题。

## 八：锁的分类 ##

1.  乐观锁与悲观锁  
    悲观锁：对数据修改持有保守态度，认为数据很容易给修改，例如synchronized。  
    乐观锁：对数据的读取很放心，在进行数据提交的时候才会对数据是否冲入进行检测。
2.  公平锁与非公平锁  
    公平锁：获取锁时，会根据线程的先来后到时间来决定锁的归属。  
    非公平锁：获取锁时，会随机选择一个线程决定锁的归属。
3.  独占锁与共享锁  
    独占锁：只能由单个线程来使用，其他需求线程只能等待上一个线程使用完锁，例如Synchronized。  
    共享锁：允许多个线程同时进行操作，例如ReadWriteLock读写锁，允许多线程进行读操作。
4.  可重入锁  
    在获取锁的基础，再次获取锁。例如synchronized
5.  自旋锁  
    当线程获取自选锁时，获取不到锁并不会立马进入挂起状态，而会持续进行锁的尝试获取，知道一定次数，次数用尽后，才会挂起。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDA4NTM1_size_16_color_FFFFFF_t_70]: /images/20220131/5f03c0550b36464bacdb61fdd23a411d.png
[CPU]: /images/20220131/4d0768fe755142ccae0fd6c64f31307e.png
[Unsafe]: /images/20220131/8732fa4b258c4a6184f2bf1f81b2e7b9.png
[JVM]: /images/20220131/be66e786439549908fb497248c81d629.png
[CPU 1]: /images/20220131/ca7a5e6652344eb4a9259fb67e95b663.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDA4NTM1_size_16_color_FFFFFF_t_70 1]: /images/20220131/09bce15bfbb4400880922d0cc042bc83.png