基础概念
CPU核心数和线程数的比例：1:1，超线程技术比例：1:2
CPU时间片轮转机制（RR调度），涉及线程上下文切换
进程和线程
- 进程：程序运行资源分配的最小单位，一个进程内部有多个线程，共享这个进程的资源，进程可独立运行，进程之间相互独立
- 线程：CPU调度的最小单位，线程本身不能独立运行，必须依附于进程，自己不能申请资源，只能共享使用进程的资源
并行和并发
- 并行：同一时刻可以处理事情的能力
- 并发：与单位时间相关，一定单位时间内处理事情的能力
- 举例1：食堂有8个窗口可同时打饭，则食堂打饭的并行数为8，一分钟内一个窗口可以为3个学生服务，则一分钟内食堂都并发数为 8 * 3 = 24
- 举例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);
}
}
}
实例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();
}
}
}
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执行完成...
