并发和并行
并发： 在同一时刻，多个指令在单一CPU上交替指向
并行：在同一时刻，多个指令在多个CPU上同时执行
2核4线程，4核8线程，8核16线程，16核32线程
基础实现线程的方式
- Thread :继承类 ，无返回
- Runnable ：实现接口，无返回
- Callable 核 TaskFurture ： 实现接口，有返回
public static void main(String[] args) {MyThread t1 = new MyThread();t1.setName("自定义线程-1");MyThread t2 = new MyThread("自定义线程-2");t1.start();t2.start();}static class MyThread extends Thread{// int ticket = 100; // 单个线程私有
// static int ticket = 100; // MyThread类启动的多线程共有public MyThread() {}public MyThread(String name) {super(name);}@Overridepublic void run() {for (int i=1;i<1000;i++){System.out.println(Thread.currentThread().getName()+" "+i);}}}public class RunnableMain {public static void main(String[] args) {MyRunnable r1 = new MyRunnable();Thread t1 = new Thread(r1,"自定义线程-1");Thread t2 = new Thread(t1,"自定义线程-2");t1.start();t2.start();}static class MyRunnable implements Runnable{// int ticket = 100; // 线程共享@Overridepublic void run() {for (int i=1;i<1000;i++){System.out.println(Thread.currentThread().getName()+" "+i);}}}
}public class CallableMain {public static void main(String[] args) throws ExecutionException, InterruptedException {MyCallable c1 = new MyCallable();FutureTask<Integer> f1 = new FutureTask<>(c1);Thread t1 = new Thread(f1);t1.start();System.out.println(f1.get());}static class MyCallable implements Callable<Integer>{@Overridepublic Integer call() throws Exception {Integer count = 0;for (int i=1;i<1000;i++){count+=i;}return count;}}
}常见的成员方法
| 方法名称 | 说明 |
| String getName() | 返回此线程的名称 |
| void setName() | 设置线程的名称 |
| static Thread currentThread() | 获得当前线程对象 |
| static void sleep(long time) | 让当前线程休眠，单位：毫秒 |
| setPriority(int newPriority) | 设置线程优先级，1-10，10最大优先级，默认5 |
| final int getPriority() | 获取线程的优先级 |
| final void setDaemon(boolean on) | 设置为守护线程,其他非守护线程的线程结果，守护线程也将结束 |
| public static void yield() | 礼让线程，让线程跑得更均匀 |
| public staic void join() | 插入线程，插入得线程跑完再继续执行被插入线程 |
生命周期
同步代码块synchronized ()，同步方法，local锁
// lock是接口，用ReentrantLock实现
Lock reentrantLock = new ReentrantLock();
reentrantLock.lock();
reentrantLock.unlock();
注意退出的时候，是否带锁退出，最好放在finally块里死锁：相互等待
等待/唤醒
锁.wait();
锁.notifyAll(); //唤醒所有这两个方法必须在同步代码块内部调用交替执行：
public class MyArrayBlockingQueue {static Integer count = 10;static Integer hasFood = 0;static Object obj = new Object();public static void main(String[] args) {Cooker cooker = new Cooker();Eater eater = new Eater();Thread t1 = new Thread(cooker);Thread t2 = new Thread(eater);t1.start();t2.start();}@Datastaticclass Cooker implements Runnable {private ArrayBlockingQueue abq;@Overridepublic void run() {while (true) {if (count == 0) {break;} else {synchronized (MyArrayBlockingQueue.obj) {if (hasFood == 1) {// 有食物try {MyArrayBlockingQueue.obj.wait();} catch (InterruptedException e) {e.printStackTrace();}} else {hasFood++;System.out.println("做了一份菜");MyArrayBlockingQueue.obj.notifyAll();}}}}}}@Datastaticclass Eater implements Runnable {private ArrayBlockingQueue abq;@Overridepublic void run() {while (true) {if (count == 0) {break;} else {synchronized (MyArrayBlockingQueue.obj) {if (hasFood == 0) {// 没有食物try {MyArrayBlockingQueue.obj.wait();} catch (InterruptedException e) {e.printStackTrace();}} else {hasFood--;count--;System.out.println("吃了一份菜，还剩下" + count + "容量的肚子");MyArrayBlockingQueue.obj.notifyAll();}}}}}}}阻塞队列
继承：
Iterable -> Collection -> Queue -> BlockingQueue -> ArrayBlockQueue(数组有界) / LinkedBlockQueue（数组无界）
线程池
// 获取一个单线程的线程池：
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();// 获取FixThread 线程池： 指定活跃线程数量2
ExecutorService executorService = Executors.newFixedThreadPool(2);// 创建一个可缓存的线程连接池,无限大（完全取决于操作系统最大允许多少）
// 超过60秒自动回收
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();// 1. 获取周期性线程池, 传入核心线程的大小
ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(2);
多线程(二) | 彻底搞懂线程池-Executors_executor.submit-CSDN博客
)
