Java并发编程的艺术-并发编程问题

来源：Java并发编程的艺术

并发编程会遇到的问题。

上下文切换问题。
死锁问题。
线程中如何通信。（这里指的线程是指并发执行的活动实体）
线程中如何同步。
Java之间的通信由Java内存模型（JMM）控制。
以及受限于硬件和软件的资源限制问题。

进程，线程。

• 进程：操作系统分配资源的最小单位。（最少一个线程）
• 线程：CPU可调度的最小单位。

上下文切换问题和解决方案

上下文切换：CPU通过时间片分配算法来循环执行任务，当前任务执行一个时间片后会切换到下一个任务。但是，在切换前会保留上一个任务的状态，以便下次切换回这个任务时，可以再加载这个任务的状态。所以任务从保存到再加载的过程就是一次上下文切换。

解决方案：

• 无锁并发编程：多线程竞争锁时，会引起上下文切换，所以多线程处理数据时，可以用一些办法来避免使用锁，如将数据的ID按照Hash算法取模分段，不同线程处理不同段的数据。
• CAS算法：Java的Atomic包使用CAS算法来更新数据，不需要加锁。
• 使用最少线程：避免创建不需要的线程，比如任务很少，但是创建了很多线程来处理，这样会造成大量线程都处于等待状态
• 协程：在单线程里实现多任务调度，并在单线程里维持多个任务间的切换。

死锁，实现

线程t1和线程t2互相等待对方释放锁，造成某些功能不能使用，一旦出现死锁，业务是可以感知的，因为不能继续提供服务了，可以通过dump线程查看到底是哪个线程出现了问题。

public class DeadlockTest {
    两个共享变量;根据加锁的位置看是否需要将变量设置为可见性的。
    private static String sharedA="1";
    private static String sharedB="2";
    public static void main(String[] args) {
        Thread threadA=new Thread(() -> {
            锁内读写，其他线程的缓存会失效，进入snc时线程就会去拿监视锁把sharedA锁住，独占锁。
            synchronized (sharedA){
                try {
                    System.out.println(Thread.currentThread().getName()+"已经获取到sharedA的锁"+"sharedA="+sharedA);
                    拿到sharedA锁后让线程睡眠，不让线程立即去获取sharedB的锁
                    Thread.sleep(1000);
                    System.out.println(Thread.currentThread().getName()+"尝试获取sharedB的锁");
                    synchronized (sharedB){
                        System.out.println("已经获取到B的锁");
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    Thread.currentThread().interrupt();
                }
            }
        },"线程A");
        Thread threadB=new Thread(() -> {
            造成一个互斥的实现死锁。
            synchronized (sharedB){
                try {
                    System.out.println(Thread.currentThread().getName()+"已经获取到sharedB的锁"+"sharedB="+sharedB);
                    Thread.sleep(1000);
                    System.out.println(Thread.currentThread().getName()+"尝试获取sharedA的锁");
                    synchronized (sharedA){
                        System.out.println();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    Thread.currentThread().interrupt();
                }
            }
        },"线程B");
        threadA.start();
        threadB.start();
    }
}

• JConsle（进入java/bin，一种可视化工具）
• Jps查看进程名字Jstack -l 端口号
  查看死锁方法

避免死锁的几个常见方法

1. 避免一个线程同时获取多个锁
2. 避免一个线程在锁内同时占用多个资源，尽量保证每个锁只占用一个资源
3. 尝试使用定时锁，使用lock.tryLock(timeout)来代替使用内部锁机制
4. 对于数据库锁，加锁和解锁必须在一个数据库连接里，否则会出现解锁失败的情况

并发编程模型的两个关键问题

1. 线程之间如何通信（通信是指线程之间以何种机制来交换信息）。
   命令式编程中，线程之间的通信机制：共享内存、消息传递。
   共享内存：线程之间共享程序的公共状态，通过读写内存中的公共状态进行隐式通信。（Java中采用共享内存模型，由JMM控制）
   消息传递：线程之间没有公共状态，线程之间必须通过发送消息来显示进行通信。
   JMM决定一个线程对共享变量的写入何时对另一个线程可见。
2. 线程之间如何同步（线程指并发执行的活动实体）。
   共享内存并发模型里，同步时显示进行的。（程序必须显示指定某个方法或某段代码需要在线程之间互斥执行）
   消息传递的并发模型里，消息的发送必须在消息接收之前，同步时隐式进行的。