Java多线程系列之：多线程一些基本概念
一，基础概念
1，CPU核心数和线程的关系
CPU核心数：最早的cpu是单核的。后来出现了多核cpu（2核,4核）
CPU和线程的个数是1：1的关系。比如4核可以允许4个线程同时运行。后来intel提出了超线程的概念。使cpu和线程个数1:2。
2，CPU时间片轮转机制
给每一个进程分配一个时间段,这个时间段就被称为进程的时间片 ---> 这个进程允许运行的时间。
不同进程在cpu上执行，cpu需要进行不同进程之间的切换。每次切换需要耗费5000-20000个时钟周期。这其实是浪费了cpu的资源。
我们在开发时，尽量减少让cpu去进行进程间的切换。
3，什么是线程和进程
进程：程序运行进行资源分配的最小单位。一个进程内部有多个线程,多个会共享这个进程的资源
线程：CPU调度的最小单位，线程不拥有资源。线程依附于进程。
4，并行和并发
并行：某一个时间点，可以处理的事情（同一时刻，可以处理事情的能力）
并发：与时间单位相关，某个时间段内，可以处理的事情（单位时间内可以处理事情的能力）
二，认识Java里的线程
1，Java里的程序天生就是多线程的，比如我们执行main方法时，并不是只有main这个主线程，还有别的线程在运行：
/** * java天生就是多线程的 */ public class OnlyMain { public static void main(String[] args) { //Java虚拟机线程管理的接口。 ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean(); //通过这个类可以拿到当前应用程序有多少个线程 ThreadInfo[] threadInfos = threadMXBean.dumpAllThreads(false,false); for (ThreadInfo threadInfo:threadInfos){ System.out.println("["+threadInfo.getThreadId()+"] "+threadInfo.getThreadName()); } /** * 打印结果：说明执行main方法时至少启动了5个线程 [5] Monitor Ctrl-Break [4] Signal Dispatcher [3] Finalizer [2] Reference Handler [1] main main方法线程 */ } }
2，启动新线程的三种方式：
/** * 创建线程的三种方式 */ public class NewThread { /** 方式一：扩展自Thread类 */ private static class UseThread extends Thread{ @Override public void run() { System.out.println("i am extends Thread"); } } /** 方式二：实现Runnable */ private static class UseRun implements Runnable{ @Override public void run() { System.out.println("i am implements Runnable"); } } /* 方式三：实现Callable接口，允许有返回值 */ private static class UseCall implements Callable<String>{ @Override public String call() throws Exception { System.out.println("i am implements Callable"); return "CallResult"; } } public static void main(String[] args) throws InterruptedException,ExecutionException{ //Thread启动线程 UseThread useThread = new UseThread(); useThread.start(); //Runnable启动线程 UseRun useRun = new UseRun(); new Thread(useRun).start(); //Callable启动线程 UseCall useCall = new UseCall(); /** * 注意： * 1,Callable是不能直接交给Thread的 * 2,可以把Callable包装成Runnable。FutureTask实现了Runnable接口 * 3,包装成Runnable后，交给Thread */ FutureTask<String> futureTask = new FutureTask<String>(useCall); new Thread(futureTask).start(); //我们可以从Callable拿到返回值。注意：get()方法是阻塞的 String result = futureTask.get(); System.out.println(result); } }
3，Java提供了Thread类，为什么还要提供Runnable接口？
从面向对象的角度思考：Java是单继承的，提供Runnable接口可以多实现。
4，如何让Java里的线程安全的停止工作？
4.1，三种方式：
方式一：线程正常运行结束
方式二：运行过程中抛出了异常
方式三：Java提供的方法：
suspend()：调用该方法后，线程是不会释放资源的。比如该线程有锁，他不会释放这把锁。容易发生死锁
stop()：调用该方法后，强行终止线程。无法保证线程资源正常释放。
resume():
方式四：建议使用的方法(中断线程安全的方法)：
interrupt():中断一个线程,并不是强行关闭这个线程。只是把一个中断标志设置为true
isInterrupted():判定当前线程是否处于中断状态。判断中断标志是否为true
静态的interrupted():判定当前线程是否处于中断状态。 把中断标志改为false
4.2，注意：
java线程是协作式进行工作的，所以别的线程调用interrupt()并不是强行关闭这个线程，而是对该线程打个招呼。该线程会不会立即停止工作，完全由该线程自己做主。
示例代码：
public static void main(String[] args){ UseRun useRun = new UseRun(); Thread thread = new Thread(useRun); //main线程对thread线程打了个招呼，至于thread线程会不会停止,完全自己做主 thread.interrupt(); }
三，深入理解Java线程
1，线程的生命周期
2，start()和run()的区别
thread.start():开启一个新的线程，然后该线程会运行run()方法
thread.run():就是单纯的调用run()方法，不会开启一个新的线程
3，了解yield():
将线程从运行转到可运行状态(就绪态)，放弃了当前cpu资源，进入就绪态，然后和其他线程一起去竞争cpu资源
4，线程的优先级
设置线程的优先级：thread.setPriority(int priority); 优先级：1-10
注意：理论上来说，线程的优先级越高，就越先被执行。有些操作系统会忽略我们设置的优先级。所以了解就行
5，守护线程
和主线程共死的（主线程退出，守护线程也会退出。比如垃圾回收线程）
public class DaemonThread { private static class UseThread extends Thread{ @Override public void run() { while (true){ System.out.println(Thread.currentThread().getName()+"i am daemon Thread"); } } } public static void main(String[] args)throws InterruptedException { Thread endThread = new UseThread(); /** * 注意：必须在start()方法之前, * 如果主线程执行完毕，守护线程也停止. */ endThread.setDaemon(true); endThread.start(); Thread.sleep(1); /** * 在main主线程睡眠的这一1ms期间,守护线程一直在运行,当main线程执行完毕,守护线程也退出 * 打印结果： * Thread-0i am daemon Thread Thread-0i am daemon Thread Thread-0i am daemon Thread ... */ } }
四，线程间的共享
1，什么是线程间的共享
2，如何实现线程间的共享
2.1，synchronized内置锁
分为类锁和对象锁：
对象锁：锁代码块，锁方法
类锁：static+synchronized : public static synchronized void method(){}
能不能同时运行：
同一个对象锁，不能同时运行
两个不同的对象锁，可以同时运行
一个类锁和一个对象锁，可以同时运行
两个类锁，不能同时运行。 因为每个类的Class对象只有一个,所以还是同一把锁。
区别：
对象锁，锁的是new出来的对象实例
类锁，锁的是每个类的Class对象
2.2，volatile关键字：最轻量的同步机制
保证了可见性：修改了数据后，强制把数据刷到主内存。读取数据时，强制从主内存中读取数据。
但是不保证原子性：即 a = a+1;不是一步完成的。操作系统会执行好几条指令才完成加1操作。
Volatile的使用场景：
只有一个线程写，多个线程读。
2.3，ThreadLocal的使用
每个线程只是用自己线程的变量，把数据和当前线程绑定
案例：我在当前线程中保存该用户的信息，那么在用户的请求线程进入程序时把用户的信息和当前线程绑定，当用户的请求线程结束，我再把这个线程移除。
如何实现：
public class RequestHolder { private static final ThreadLocal<String> userHolder = new ThreadLocal<>(); public static void add(String sysUser) { userHolder.set(sysUser); }public static String getCurrentUser() { return userHolder.get(); }public static void remove() { userHolder.remove(); } }
在拦截器的preHandle()方法中把线程和用户信息绑定，在postHandle()方法中把该线程销毁
@Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { RequestHolder.add(authorization);//这里我绑定的是token return true; } @Override public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception { // 正常返回时, 显式回收threadLocal里的信息 RequestHolder.remove(); }
在我需要获取用户信息的地方（比如Service中的方法），通过线程对应的用户信息
String token = RequestHolder.getCurrentUser();
五，线程间的协作
1，轮询：难以保证及时性，资源开销很大
2，等待和通知
等待和通知的标准范式：
等待方：
要去获取对象的锁，
然后在循环里判断条件是否满足，不满足调用wait方法。
条件满足，执行业务逻辑
通知方：
获取对象的锁
改变条件
通知所有等待在对象的线程
3，方法：
wait()：等待着获取对象的锁
wait(1000)：等待超时，超过一定时间就不等待了。
notify:通知一个线程
notifyAll:通知所有等待同一把锁的线程
4，join()方法
面试问题：有线程A和线程B,如何保证线程B一定在线程A执行完以后才执行？
方法一：join()
方法二：countDownLatch
解释：如果线程A执行了线程B的join方法，线程A必须等待线程B执行完了以后，线程A才能继续自己的工作。
5，yield(),sleep(),wait(),notify()等方法对锁的影响
线程在执行yield()以后,持有的锁是不释放的
sleep()方法调用以后，持有的锁是不释放的
wait()：在调用wait()方法之前，必须要持有锁。在调用wait()方法以后。锁就会被释放（虚拟机进行释放）,当wait方法返回时，线程会重新持有锁
notify():在调用之前，必须要持有锁。调用notify()方法本身是不会释放锁的，只有synchronized代码块执玩才释放锁
notifyAll()：同notify()
比如：public synchronized void changeKm(){
this.km = 101;
notify();//当执行完这行代码时，此时还没有释放锁。
System.out.println("处理业务逻辑"); //执行完这一行代码后,才释放锁。
}
