回炉重造java----JUC(第一天)

本文主要是介绍回炉重造java----JUC(第一天)，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

JUC前置知识
①进程和线程的区别？
②并行和并发的区别？
③异步调用和同步调用的区别？
④创建线程的方法
⑤线程的上下文切换
⑥TimeUtil
⑦Interrupt
⑧如何在一个线程中终止另外一个线程？
⑨线程的状态
共享模型之管程
阻塞式：Synchronized
线程八锁问题
变量的线程安全分析
常见的线程安全类
Monitor

JUC前置知识

①进程和线程的区别？

①其根本区别在于进程是操作系统资源分配的基本单位，而线程是CP任务调度和执行的基本单位。

②一个进程可以有多个线程，至少有一个，而一个线程只能属于一个进程。

③同一个线程里的进程共享资源，而进程之间的资源是相互独立的。

④开销方面，创建，切换或者销毁一个进程的开销明显大于线程的创建，切换和开销。

⑤通信方面，进程间通信相对复杂，一般是要通过网络进行通信，而线程之间因为是共享线程的资源，所以通信相对简单。

②并行和并发的区别？

①并发：当有多个线程在执行时，但是如果系统是单核CPU系统时，CPU在同一时刻只能执行一个线程，也叫作串行执行，但是CPU会通过时间片的方式进行线程之间的切换执行，一般把这种线程轮流使用CPU的方式叫做并发。

②并行：上面讲的是系统在单核CPU下的情况，但是如果系统是多核CPU时，在同一时刻会有多个线程被执行，线程之间互不干扰，这就叫做并行。

③异步调用和同步调用的区别？

①同步通常指的是事件、操作或进程之间的有序关系。在一个同步场景中，一个操作必须在另一个操作完成后才能开始执行。同步还可以指代多个线程或进程在执行过程中需要进行协调，例如通过锁、信号量等机制来确保数据一致性或避免竞争条件。

②异步描述的是事件、操作或进程之间相互独立的关系。在异步场景中，一个操作可以在不等待其他操作完成的情况下开始执行。异步操作使得多个任务可以独立进行，从而提高系统的并发性能和响应能力。

④创建线程的方法

①继承Thread类，重写Run方法

②实现Runnable接口，重写Run方法

③实现Callable接口，重写call方法

④线程池

⑤线程的上下文切换

注：sleep不释放锁，但是会让出CPU

⑥TimeUtil

public enum TimeUnit {/*** Time unit representing one thousandth of a microsecond*/NANOSECONDS {public long toNanos(long d)   { return d; }public long toMicros(long d)  { return d/(C1/C0); }public long toMillis(long d)  { return d/(C2/C0); }public long toSeconds(long d) { return d/(C3/C0); }public long toMinutes(long d) { return d/(C4/C0); }public long toHours(long d)   { return d/(C5/C0); }public long toDays(long d)    { return d/(C6/C0); }public long convert(long d, TimeUnit u) { return u.toNanos(d); }int excessNanos(long d, long m) { return (int)(d - (m*C2)); }},/*** Time unit representing one thousandth of a millisecond*/MICROSECONDS {public long toNanos(long d)   { return x(d, C1/C0, MAX/(C1/C0)); }public long toMicros(long d)  { return d; }public long toMillis(long d)  { return d/(C2/C1); }public long toSeconds(long d) { return d/(C3/C1); }public long toMinutes(long d) { return d/(C4/C1); }public long toHours(long d)   { return d/(C5/C1); }public long toDays(long d)    { return d/(C6/C1); }public long convert(long d, TimeUnit u) { return u.toMicros(d); }int excessNanos(long d, long m) { return (int)((d*C1) - (m*C2)); }},/*** Time unit representing one thousandth of a second*/MILLISECONDS {public long toNanos(long d)   { return x(d, C2/C0, MAX/(C2/C0)); }public long toMicros(long d)  { return x(d, C2/C1, MAX/(C2/C1)); }public long toMillis(long d)  { return d; }public long toSeconds(long d) { return d/(C3/C2); }public long toMinutes(long d) { return d/(C4/C2); }public long toHours(long d)   { return d/(C5/C2); }public long toDays(long d)    { return d/(C6/C2); }public long convert(long d, TimeUnit u) { return u.toMillis(d); }int excessNanos(long d, long m) { return 0; }},/*** Time unit representing one second*/SECONDS {public long toNanos(long d)   { return x(d, C3/C0, MAX/(C3/C0)); }public long toMicros(long d)  { return x(d, C3/C1, MAX/(C3/C1)); }public long toMillis(long d)  { return x(d, C3/C2, MAX/(C3/C2)); }public long toSeconds(long d) { return d; }public long toMinutes(long d) { return d/(C4/C3); }public long toHours(long d)   { return d/(C5/C3); }public long toDays(long d)    { return d/(C6/C3); }public long convert(long d, TimeUnit u) { return u.toSeconds(d); }int excessNanos(long d, long m) { return 0; }},/*** Time unit representing sixty seconds*/MINUTES {public long toNanos(long d)   { return x(d, C4/C0, MAX/(C4/C0)); }public long toMicros(long d)  { return x(d, C4/C1, MAX/(C4/C1)); }public long toMillis(long d)  { return x(d, C4/C2, MAX/(C4/C2)); }public long toSeconds(long d) { return x(d, C4/C3, MAX/(C4/C3)); }public long toMinutes(long d) { return d; }public long toHours(long d)   { return d/(C5/C4); }public long toDays(long d)    { return d/(C6/C4); }public long convert(long d, TimeUnit u) { return u.toMinutes(d); }int excessNanos(long d, long m) { return 0; }},/*** Time unit representing sixty minutes*/HOURS {public long toNanos(long d)   { return x(d, C5/C0, MAX/(C5/C0)); }public long toMicros(long d)  { return x(d, C5/C1, MAX/(C5/C1)); }public long toMillis(long d)  { return x(d, C5/C2, MAX/(C5/C2)); }public long toSeconds(long d) { return x(d, C5/C3, MAX/(C5/C3)); }public long toMinutes(long d) { return x(d, C5/C4, MAX/(C5/C4)); }public long toHours(long d)   { return d; }public long toDays(long d)    { return d/(C6/C5); }public long convert(long d, TimeUnit u) { return u.toHours(d); }int excessNanos(long d, long m) { return 0; }},/*** Time unit representing twenty four hours*/DAYS {public long toNanos(long d)   { return x(d, C6/C0, MAX/(C6/C0)); }public long toMicros(long d)  { return x(d, C6/C1, MAX/(C6/C1)); }public long toMillis(long d)  { return x(d, C6/C2, MAX/(C6/C2)); }public long toSeconds(long d) { return x(d, C6/C3, MAX/(C6/C3)); }public long toMinutes(long d) { return x(d, C6/C4, MAX/(C6/C4)); }public long toHours(long d)   { return x(d, C6/C5, MAX/(C6/C5)); }public long toDays(long d)    { return d; }public long convert(long d, TimeUnit u) { return u.toDays(d); }int excessNanos(long d, long m) { return 0; }};

Thread中sleep的技巧：

        Thread.sleep(500);//默认是毫秒TimeUnit.MILLISECONDS.sleep(500);

sleep的技巧：

⑦Interrupt

如果是打断sleep或者wait或者join的线程，Isinterrupt()返回的结果依旧是FALSE，但是会通过抛出异常的方式回应。

如果是打断正在运行的进程，Isinterrupt()返回的结果就是TRUE。但是只是设置这个标记，不会真正的直接停掉线程。

⑧如何在一个线程中终止另外一个线程？

⑨线程的状态

①New：新建状态。

②Runnable：可运行状态（其包含了可运行，正在运行和IO阻塞）。

③Blocked：阻塞状态(像拿不到锁阻塞等待)。

④Waiting：等待状态，一般要使用notify或者notifyAll方法唤醒。

⑤Timed_Waiting：超时等待状态。

⑥Terminated：终止状态。所以当你第二次调用start方法的时候就会报错。

共享模型之管程

并发：原子性，可见性和有序性

阻塞式：Synchronized

实际上是使用对象锁保证了临界区内代码的原子性。

public class syntest {private static Object object = new Object();private static int num=0;public static void main(String[] args) throws InterruptedException {//创建一个线程Thread t1 = new Thread(() -> {for (int i = 0; i < 10; i++) {synchronized (object){System.out.println("线程一获得了锁");num++;}}}, "t1");//创建一个线程Thread t2 = new Thread(() -> {for (int i = 0; i < 10; i++) {synchronized (object){System.out.println("线程二获得了锁");num--;}}}, "t2");t1.start();t2.start();t1.join();t2.join();System.out.println(num);}
}

synchronize可以锁对象，也可以锁成员方法(锁的是this对象)，还可以锁静态方法(锁的是该类)