线程基础、线程之间的共享和协作

基础概念

CPU核心数和线程数的比例：1:1，超线程技术比例：1:2

CPU时间片轮转机制（RR调度），涉及线程上下文切换

进程和线程

• 进程：程序运行资源分配的最小单位，一个进程内部有多个线程，共享这个进程的资源，进程可独立运行，进程之间相互独立
• 线程：CPU调度的最小单位，线程本身不能独立运行，必须依附于进程，自己不能申请资源，只能共享使用进程的资源

并行和并发

• 并行：同一时刻可以处理事情的能力
• 并发：与单位时间相关，一定单位时间内处理事情的能力

1. 举例1：食堂有8个窗口可同时打饭，则食堂打饭的并行数为8，一分钟内一个窗口可以为3个学生服务，则一分钟内食堂都并发数为 8 * 3 = 24
2. 举例2：CPU的核心数为8，则CPU的并发数为8，CPU的时间片分隔执行周期为100ms，则1秒内CPU并发数为 1000 / 100 * 8 = 80

高并发的意义

• 充分利用CPU资源
• 加快用户响应时间
• 使代码模块化，异步化处理

高并发的注意事项

• 资源共享，会导致线程冲突，照成线程死锁
• 创建多过的线程，会导致资源枯竭

Java线程

Java启动线程的方式

• 继承Thread类
• 实现Runnable接口，无返回值
• 实现Callable接口，有返回值

线程结束

• 程序执行完成，自然结束
• 抛出异常结束
• stop()、resume()、pause()，暴力停止，线程资源无法释放，不建议使用
• interrupt()、interrupted()、isInterrupted()三种java线程协作方式停止线程
• thread.interrupt()：中断当前thread线程，并不是强制关闭线程，而且将中断标记位设置为true，线程在某一个时刻中断，无法控制
• thread.isInterrupted()：仅返回thread线程中断状态
• static interrupted()：静态方法，作用于当前所在线程，返回当前线程的中断状态，并会将中断标记位设置为false
• 线程抛出InterruptedException异常时，会重置中断标记位为false，需再次调用interrupt()方法才可退出循环

参考：https://www.jianshu.com/p/4da928eed5e8

线程的生命周期

未命名文件2.jpg

线程的优先级：myThread.setPriority(6); // 1 - 10之间，不一定生效

守护线程：如果主线程结束，则守护线程强制结束

myThread.setDaemon(true)

注：守护线程会导致线程内的finally()方法不一定会执行，导致资源无法释放

sleep,wait,yield,join的区别

• sleep()：在指定时间内让正在运行的线程暂停，使线程进入暂停状态，sleep()并不会释放锁
• wait()：在其他线程调用notify()或notifyAll()方法之前，线程阻塞，wait()方法会释放锁，这样别的线程有机会竞争到锁，wait()、notify()、notifyAll()必须在synchronized方法块或者修饰的方法上使用
• yield()：暂停正在执行的线程，yield()方法只是将线程的状态由运行状态变成就绪状态，可能会在一个执行周期抢占到了资源，由就绪状态变成运行状态重新执行，所以yield()方法调用后线程只需要重新获取CPU的机会，sleep()方法得等到固定时间结束后才会进入就绪状态
• join()：等待调用join()方法的实例所代表的线程执行完成后，当前线程才能继续执行，比如main线程中调用了t.join()，则主线程需要等待t线程结束后才会继续执行

线程共享

synchronized：内置锁

• 对象锁：锁的范围是对象
• 类锁：锁的范围是类对应的class对象

volatile：最轻量级的同步机制，强制线程从主内存获取值，可以保障线程的可见性，但无法保障线程的原子性，volatile是非线程安全的

ThreadLocal：空间换线程安全，每个线程保存了对象的副本，对象之间相互独立

wait()、notify()、notifyAll()方法

wait()：调用wait()时，当前线程进入阻塞状态，并释放锁，等待别的线程调用notify()或notifyAll()方法唤醒
notify()：调用notify()方法通知唤醒某一个wait()方法所阻塞等待的线程
notifyAll(): 通知唤醒所有因调wait()方法所阻塞等待的线程

等待通知机制

等待方：
1、获取对象锁
2、循环判断是否满足处理的条件，不满足调用wait()方法
3、满足条件执行业务逻辑
通知方：
1、获取对象锁
2、改变条件
3、通知所有等待在锁对象上的线程

实例1：wait()、notifyAll()实现一个快递通知，当快递的里程数>100公里或者城市发生变化时给用户通知

/**
 * 当快递的公里数大于100公里或城市不在北京时，给客户发出提醒消息
 */
public class Express {

    public static final String CURR_CITY = "北京";

    private Object object = new Object();

    /**
     * 快递行走的公里数
     */
    private int km;

    /**
     * 快递当前位置
     */
    private String site = "北京";

    /**
     * 修改快递公里数
     * @param km
     */
    public void changeKm(int km) {
        synchronized (object) {
            System.out.println(Thread.currentThread().getName() + " km : " + km);
            this.km = km;
            object.notifyAll();
        }
    }

    /**
     * 修改快递城市
     * @param city
     */
    public void changeSite(String city) {
        synchronized (object) {
            System.out.println(Thread.currentThread().getName() + " site : " + site);
            this.site = city;
            object.notifyAll();
        }
    }

    /**
     * 等待公里数变化
     */
    public void waitKm() throws InterruptedException {
        synchronized (object) {
            while (this.km <= 100) {
                object.wait();
                System.out.println(Thread.currentThread().getName() + " check km...");
            }
            System.out.println(Thread.currentThread().getName() + " , send change, curr km : " + km);
        }
    }

    /**
     * 等待城市变化
     */
    public void waitSite() throws InterruptedException {
        synchronized (object) {
            while (CURR_CITY.equals(site)) {
                object.wait();
                System.out.println(Thread.currentThread().getName() + " check site...");
            }
            System.out.println(Thread.currentThread().getName() + " send change, curr site : " + site);
        }
    }
}

完整代码: https://github.com/shawntime/test-enjoy-architect/tree/master/test-concurrency/src/main/java/com/shawntime/enjoy/architect/concurrency/waitandnotify/express

实例2：实现一个自定义的数据库连接池

/**
 * 自定义实现线程池
 */
public class DBPool {

    private LinkedList<MyConnection> DB_POOL = new LinkedList<>();

    private static final int INITIALIZE_SIZE = 10;

    private Object lock = new Object();

    public DBPool(int initializeSize) {
        int size = initializeSize;
        if (initializeSize <= 0) {
            size = INITIALIZE_SIZE;
        }
        for (int i = 0; i < size; ++i) {
            MyConnection connection = new MyConnection();
            DB_POOL.add(connection);
        }
    }

    /**
     * 获取链接
     */
    public MyConnection getConnection(long waitTime) throws InterruptedException {
        synchronized (lock) {
            if (waitTime <= 0) {
                while (DB_POOL.isEmpty()) {
                    lock.wait();
                }
                return DB_POOL.removeFirst();
            } else {
                long endTimeStamp = System.currentTimeMillis() + waitTime;
                long remainTime = waitTime;
                while (DB_POOL.isEmpty() && remainTime > 0) {
                    lock.wait();
                    remainTime = endTimeStamp - System.currentTimeMillis();
                }
                if (DB_POOL.isEmpty()) {
                    return null;
                }
                return DB_POOL.removeFirst();
            }
        }
    }

    /**
     * 释放连接
     */
    public void releaseConnection(MyConnection connection) {
        if (connection == null) {
            return;
        }
        synchronized (lock) {
            DB_POOL.addLast(connection);
            lock.notifyAll();
        }
    }
}

完整代码见： https://github.com/shawntime/test-enjoy-architect/tree/master/test-concurrency/src/main/java/com/shawntime/enjoy/architect/concurrency/waitandnotify/pool

yield()、wait()、notify()/notifyAll()、sleep()方法对锁的影响

• yield()：暂停正在执行的线程，线程由进行状态转换为就绪状态，但不会释放锁
• sleep()：暂停正在执行的线程，线程由进行状态转换为暂停状态，也不会释放锁
• wait()：阻塞当前线程，调用wait()方法之前，必须先获取到锁，调用wait()方法之后会释放锁，当wait()方法返回时又会重新获取锁
• notify()、notifyAll()：调用notify()方法之前必须持有锁，唤醒wait()方法阻塞的线程，其本身方法并不会释放锁，而是要等待调用notify()的方法结束后所持有的锁释放，所以notify()一般都放在方法的最后调用

join()方法

线程A调用线程B的join()方法，则线程A要等到线程B执行结束后，线程A才能继续执行

import com.shawntime.enjoy.architect.concurrency.SleepUtils;

/**
 * join()方法测试
 */
public class JoinTest {

    private static class MyThread extends Thread {

        private Thread thread;

        public MyThread(String name, Thread thread) {
            super(name);
            this.thread = thread;
        }

        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + " waiting for " + thread.getName());
            try {
                thread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "执行完成...");
        }
    }

    public static void main(String[] args) {
        Thread thread = Thread.currentThread();
        for (int i = 0; i < 10; ++i) {
            MyThread myThread = new MyThread("my-thread" + i, thread);
            myThread.start();
            thread = myThread;
        }

        for (int i = 0; i < 3; ++i) {
            System.out.println("主线程睡眠" + (i + 1) + "秒");
            SleepUtils.sleepBySeconds(1);
        }

        System.out.println("Main方法执行完成...");
    }
}

执行结果：
Main方法执行完成...
my-thread0执行完成...
my-thread1执行完成...
my-thread2执行完成...
my-thread3执行完成...
my-thread4执行完成...
my-thread5执行完成...
my-thread6执行完成...
my-thread7执行完成...
my-thread8执行完成...
my-thread9执行完成...

join()可以让多线程串行执行