java并发编程学习(一) 并发编程的挑战

1. 上下文切换

单核的处理器也支持执行多线程代码，cpu给每个线程分配时间片来实现这个机制，时间片是cpu分配给各个线程的时间，时间片非常短，所以cpu通过不断的切换线程执行，

感觉线程是同时执行的，通常是几十ms

cpu是通过时间片分配算法来循环执行任务的，例如当前任务执行完一个时间片切换到下一个任务，但是在切换前会保存上一个任务的状态，以便再次切换回来时候，能够再次加载这个任务的状态。从保存任务到再加载这个任务的过程，就是上下文切换，上下文切换会影响多线程的执行效率

Note: 在一些并发量不高的场景中，并发执行的效率可能会比串行执行的效率更低，原因是线程有创建和上下文切换的开销.

2 .如何减少上下文切换

减少上下文切换的方法有无锁并发编程，cas算法，使用最少线程和使用协程

无锁并发编程: 多线程竞争锁时候，会引起上下文切换，采用一些措施来避免使用锁，例如，将数据的ID按照hash算法取模分段，不同线程取不同段的数据

cas 算法: 使用java atomic包的工具类无锁更新数据

最小线程 避免创建不必要的线程

协程：在单线程里实现多个任务的调度

3 .死锁

两个线程相互等待释放锁，就会导致死锁

package cn.itcast.test;
/**
* 死锁，两个线程相互等待锁，造成死锁
* @author zhouy
*
*/
public class DeadThread {
public Object lock1 = new Object();
public Object lock2 = new Object();
public void deadLock(){
Thread t1 = new Thread(new Runnable() {

@Override
public void run() {
synchronized (lock1) {
System.out.println("t1获取到lock1的锁");
try {
Thread.currentThread().sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (lock2) {
System.out.println("t1获取到lock2的锁");
}
}
}
});

Thread t2 = new Thread(new Runnable() {

@Override
public void run() {
synchronized (lock2) {
synchronized (lock1) {
System.out.println("t2获取到lock1的锁");
}
}
}
});
t1.start();
t2.start();
}
public static void main(String[] args) {
new DeadThread().deadLock();
}
}

使用synchroized锁的重入特性，演示死锁的产生，实际的业务开发场景中，可以是t1拿到锁后，没有释放导致的

避免死锁发生的常见处理:

1. 避免一个线程同时拿到多个锁

2. 避免一个线程在一个锁内，同时占有多个资源，尽量保证一个锁占有一个资源

3. 尝试使用定时锁，使用lock.tryLock(timeout)替代内部锁机制

4. 数据库锁，加锁和解锁在一个数据库连接中

4. 资源限制的挑战

实际的开发中，程序的执行速度受限于计算机的软件资源和硬件资源，比如说带宽只有2Mb/s，某个资源的下载速度是1Mb/s，启动十个线程，下载速度也不会变为10Mb/s.

常见的问题是，由于受限于资源，并发线程变为同步处理，由于并发编程引起上下文切换，可能会比单线程处理更耗费资源，处理更慢

解决资源限制的问题:

1. 硬件上创建多机环境，使用集群并行执行程序

2. 软件环境上，创建资源池，比如连接池，将数据库连接和socket复用，减少开销

小结：建议使用并发容器和工具类解决并发问题

*   学习笔记来自 阿里专家 方腾飞的《JAVA并发编程的艺术》