简单了解多线程

并发和并行

并发： 在同一时刻，多个指令在单一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博客