并发编程的目的是让程序运行的更快，同时提高CPU等硬件的使用率。但是，并不是启动更多的线程就能让程序最大限度的执行。在进行并发编程时，如果希望通过多线程执行任务让程序运行的更快，会面临非常多的挑战。

1.1上下文切换

上下文切换：CPU通过分配时间片来控制线程的执行，当一个时间片用完或者遇到锁时，CPU会切换到其他线程，但是会保存当前任务的状态，以便重新再次运行此线程时可以从停止时的状态继续运行。一个线程从暂停到再运行的过程就是一次上下文切换。

如何避免上下文切换？

• 无锁编程

  多线程并发竞争锁时，由于同一时间只会有一个线程获得锁，那么其他线程就会放弃CPU的执行权直到获取到锁，所以多线程一起协作处理数据时，避免使用锁，可以采用分片的思想，将数据分片，不同的线程处理不同的数据，避免锁竞争。

• CAS算法

  简单的int、boolean多线程并发执行时使用jdk的atomic原子类来代替锁使用。

• 使用最少线程

  一个线程最少处理一个任务，避免创建无用的线程空等待。

• 协程

  在单线程内实现多任务的调度，并在单线程内维持多个任务的切换。

1.2死锁

死锁：有a,b两个锁，有A,B两个线程，A先获得了a锁，没有释放，B先获得了b锁，没有释放，此时A执行了一段代码后又想获取b锁，但是由于B线程获得了b锁，只能等待B线程是否b锁，同时没有是否a锁，恰巧此时B线程也想获得a锁，但是由于A线程持有a锁，也只能等待A线程释放a锁，这样就导致了死锁的出现。

示例：

public static void main(String[] args) {
    final Object a = new Object();
    final Object b = new Object();
    Thread threadA = new Thread(new Runnable() {
        @Override
        public void run() {
            synchronized (a) {
                try {
                    System.out.println("threadA has lock a");
                    Thread.sleep(1000L);
                    synchronized (b) {
                        System.out.println("threadA-lock b");
                    }
                } catch (Exception e) {
                    
                }
            }
        }
    });

    Thread threadB = new Thread(new Runnable() {
        @Override
        public void run() {
            synchronized (b) {
                try {
                    System.out.println("threadB-lock b");
                    Thread.sleep(1000L);
                    synchronized (a) {
                        System.out.println("threadB-lock a");
                    }
                } catch (Exception e) {
                    
                }
            }
        }
    });

    threadA.start();
    threadB.start();
}

避免死锁的方式：

• 避免单个线程获取多个锁
• 尝试使用定时锁
• 尝试使用tryLock(long timeout)来获取锁
• 对于数据库锁，加锁和解锁必须在一个数据库连接里
• 加锁一定要记得释放锁，且加锁的次数一定和解锁的次数相同。在finally中执行解锁