Welcome to My Blog!

这里记录着我的java后端学习之路

尚硅谷JUC

2019-10-26

百味皆苦

并发

并发 JUC

什么是JUC
- 进程与线程

什么是JUC

java.util.concurrent在并发编程中使用的工具类

进程与线程

进程：进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。它是操作系统动态执行的基本单元，在传统的操作系统中，进程既是基本的分配单元，也是基本的执行单元。
大四的时候写论文，用word写论文，同时用QQ音乐放音乐，同时用QQ聊天，多个进程。
线程：通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义。线程可以利用进程所拥有的资源，在引入线程的操作系统中，通常都是把进程作为分配资源的基本单位，而把线程作为独立运行和独立调度的基本单位，由于线程比进程更小，基本上不拥有系统资源，故对它的调度所付出的开销就会小得多，能更高效的提高系统多个程序间并发执行的程度。
word如没有保存，停电关机，再通电后打开word可以恢复之前未保存的文档，word也会检查你的拼写，两个线程：容灾备份，语法检查
线程的几种状态

Thread.State
 
 
 
public enum State {
    /**
     * Thread state for a thread which has not yet started.
     */
    NEW,(新建)

    /**
     * Thread state for a runnable thread.  A thread in the runnable
     * state is executing in the Java virtual machine but it may
     * be waiting for other resources from the operating system
     * such as processor.
     */
    RUNNABLE,（准备就绪）

    /**
     * Thread state for a thread blocked waiting for a monitor lock.
     * A thread in the blocked state is waiting for a monitor lock
     * to enter a synchronized block/method or
     * reenter a synchronized block/method after calling
     * {@link Object#wait() Object.wait}.
     */
    BLOCKED,（阻塞）

    /**
     * Thread state for a waiting thread.
     * A thread is in the waiting state due to calling one of the
     * following methods:
     * <ul>
     *   <li>{@link Object#wait() Object.wait} with no timeout</li>
     *   <li>{@link #join() Thread.join} with no timeout</li>
     *   <li>{@link LockSupport#park() LockSupport.park}</li>
     * </ul>
     *
     * <p>A thread in the waiting state is waiting for another thread to
     * perform a particular action.
     *
     * For example, a thread that has called <tt>Object.wait()</tt>
     * on an object is waiting for another thread to call
     * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
     * that object. A thread that has called <tt>Thread.join()</tt>
     * is waiting for a specified thread to terminate.
     */
    WAITING,（不见不散）

    /**
     * Thread state for a waiting thread with a specified waiting time.
     * A thread is in the timed waiting state due to calling one of
     * the following methods with a specified positive waiting time:
     * <ul>
     *   <li>{@link #sleep Thread.sleep}</li>
     *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
     *   <li>{@link #join(long) Thread.join} with timeout</li>
     *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
     *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
     * </ul>
     */
    TIMED_WAITING,（过时不候）

    /**
     * Thread state for a terminated thread.
     * The thread has completed execution.
     */
    TERMINATED;(终结)
}

Read All

（MK）并发编程精讲

2019-10-25

百味皆苦

并发

并发 MK

线程八大核心基础
多线程实现方式
启动线程正确方式
正确停止线程

线程八大核心基础

多线程实现方式

实现多线程的方式有一种，两种还是四种？

官方指明实现多线程的方式有两种
方式一：继承Thread类

//描述：     用Thread方式实现线程
public class ThreadStyle extends Thread {
  
    @Override
    public void run() {
        System.out.println("用Thread类实现线程");
    }
  
    public static void main(String[] args) {
        new ThreadStyle().start();
    }
}

方式二：实现Runnable接口(优先选择)

//描述：     用Runnable方式创建线程
public class RunnableStyle implements Runnable {
  
    public static void main(String[] args) {
        Thread thread = new Thread(new RunnableStyle());
        thread.start();
    }
  
    @Override
    public void run() {
        System.out.println("用Runnable方法实现线程");
    }
}

同时使用两种方式会出现什么情况

package threadcoreknowledge.createthreads;
  
//描述：     同时使用Runnable和Thread两种实现线程的方式
public class BothRunnableThread {
  
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("我来自Runnable");
            }
        }) {
            @Override
            public void run() {
                System.out.println("我来自Thread");
            }
        }.start();
    }
}
  
//结果：我来自Thread
//原因：看Thread源码
//因为重写了Thread的run方法，所以原本的run方法就不被执行了

总结来说，创建线程只有一种方式，那就是构造Thread类，而实现线程的执行单元有两种方式。

方式一：实现Runnable接口的run方法，并把Runnable实例传给Thread类

方式二：重写Thread的run方法（集成Thread类）

错误观点：这些方式都是一些表面现象，本质都是那两种方式

线程池创建线程也算是一种新建线程的方式：内部实现也是创建的Thread对象

//描述：     线程池创建线程的方法
public class ThreadPool5 {
  
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 1000; i++) {
            executorService.submit(new Task() {});
        }
    }
}
  
class Task implements Runnable {
  
    @Override
    public void run() {
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName());
    }
}

通过Callable和FutureTask创建线程，也算是一种创建线程的方式
无返回值是实现Runnable接口，有返回值是实现callable接口，所以callable是实现线程新方式
定时器，匿名内部类，lambda表达式

//描述：     定时器创建线程
public class DemoTimmerTask {
  
    public static void main(String[] args) {
        Timer timer = new Timer();
        timer.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        }, 1000, 1000);
    }
}

//描述：     匿名内部类的方式
public class AnonymousInnerClassDemo {
  
    public static void main(String[] args) {
        new Thread() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        }.start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        }).start();
    }
}

//描述：     lambda表达式创建线程
public class Lambda {
  
    public static void main(String[] args) {
        new Thread(() -> System.out.println(Thread.currentThread().getName())).start();
    }
}

启动线程正确方式

怎样才是启动线程的正确方式？

start方法的含义

启动新线程

//描述：     对比start和run两种启动线程的方式
public class StartAndRunMethod {
  
    public static void main(String[] args) {
      Runnable runnable = () -> {
            System.out.println(Thread.currentThread().getName());
  
        };
      runnable.run();
  
        new Thread(runnable).start();
  }
}
  

准备工作

不能重复start，否则会抛出异常，因为线程有一个状态属性，每次启动线程都会去检查

package threadcoreknowledge.startthread;
  
//描述：     演示不能两次调用start方法，否则会报错
public class CantStartTwice {
    public static void main(String[] args) {
        Thread thread = new Thread();
        thread.start();
        thread.start();
    }
  
}
  

run方法的含义

Runnable target = null;
if(target != null){
  target.run();
}

启动线程应该调用start方法，从而间接的调用run方法

正确停止线程

如何正确停止线程？
原理介绍：使用interrupt来通知，而不是强制
正常中断线程

package threadcoreknowledge.stopthreads;

//描述：     run方法内没有sleep或wait方法时，停止线程
public class RightWayStopThreadWithoutSleep implements Runnable {

    @Override
    public void run() {
        int num = 0;
      //通过检查线程是否已经被中断
        while (!Thread.currentThread().isInterrupted() && num <= Integer.MAX_VALUE / 2) {
            if (num % 10000 == 0) {
                System.out.println(num + "是10000的倍数");
            }
            num++;
        }
        System.out.println("任务运行结束了");
    }

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new RightWayStopThreadWithoutSleep());
        thread.start();
        Thread.sleep(2000);
        thread.interrupt();
    }
}

睡眠情况下中断

//描述：     带有sleep的中断线程的写法
public class RightWayStopThreadWithSleep {

    public static void main(String[] args) throws InterruptedException {
        Runnable runnable = () -> {
            int num = 0;
            try {
                while (num <= 300 && !Thread.currentThread().isInterrupted()) {
                    if (num % 100 == 0) {
                        System.out.println(num + "是100的倍数");
                    }
                    num++;
                }
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        };
        Thread thread = new Thread(runnable);
        thread.start();
        Thread.sleep(500);
        thread.interrupt();
    }
}

循环内睡眠

//描述：     如果在执行过程中，每次循环都会调用sleep或wait等方法，那么不需要每次迭代都检查是否已中断
public class RightWayStopThreadWithSleepEveryLoop {
    public static void main(String[] args) throws InterruptedException {
        Runnable runnable = () -> {
            int num = 0;
            try {
                while (num <= 10000) {
                    if (num % 100 == 0) {
                        System.out.println(num + "是100的倍数");
                    }
                    num++;
                    Thread.sleep(10);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        };
        Thread thread = new Thread(runnable);
        thread.start();
        Thread.sleep(5000);
        thread.interrupt();
    }
}

中断失效，如果在sleep中进行中断，会清除中断标识，所以去检测线程是否被中断是检测不到的

//描述：     如果while里面放try/catch，会导致中断失效
public class CantInterrupt {

    public static void main(String[] args) throws InterruptedException {
        Runnable runnable = () -> {
            int num = 0;
            while (num <= 10000 && !Thread.currentThread().isInterrupted()) {
                if (num % 100 == 0) {
                    System.out.println(num + "是100的倍数");
                }
                num++;
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        Thread thread = new Thread(runnable);
        thread.start();
        Thread.sleep(5000);
        thread.interrupt();
    }
}

优先选择：传递中断

//描述：     最佳实践：catch了InterruptedExcetion之后的优先选择：在方法签名中抛出异常 那么在run()就会强制try/catch
public class RightWayStopThreadInProd implements Runnable {

    @Override
    public void run() {
        while (true && !Thread.currentThread().isInterrupted()) {
            System.out.println("go");
            try {
                throwInMethod();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                //保存日志、停止程序
                System.out.println("保存日志");
                e.printStackTrace();
            }
        }
    }

    private void throwInMethod() throws InterruptedException {
      		//向上抛出异常
            Thread.sleep(2000);
    }

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new RightWayStopThreadInProd());
        thread.start();
        Thread.sleep(1000);
        thread.interrupt();
    }
}

Read All

（MK）并发编程入门与高并发

2019-10-24

百味皆苦

并发

并发
- 概念
- 内存模型
概念
- 并发编程体系
- 项目代码
- 并发：同时拥有两个或者多个线程，如果程序在单核处理器上运行，多个线程将交替的换入或换出内存，这些线程是同时“存在”的，每个线程都处于执行过程中的某个状态，如果运行在多核处理器上，此时，程序中的每个线程都将分配到一个处理器核上，因此可以同时运行
  - 多个线程操作相同的资源，保证线程安全，合理使用资源
- 高并发：高并发（High Concurrency）是互联网分布式系统架构设计中必须考虑的因素之一，它通常是指，通过设计保证系统能够同时并行处理很多请求。
  - 服务能同时处理很多请求，提高程序性能
内存模型

同步操作
- lock（锁定）：作用于主内存的变量，把一个变量标识为一条线程独占状态
- unlock（解锁）：作用于主内存的变量，把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定。
- read（读取）：作用于主内存的变量，把一个变量的值从主内存传输到线程的工作内存中，以便以后的load动作使用。
- load（载入）：作用于工作内存的变量，它把read操作从主内存中得到的变量值放入工作内存的变量副本中。
- use（使用）：作用于工作内存的变量，把工作内存中的一个变量值传递给执行引擎。
- assign（赋值）：作用于工作内存的变量，它把一个从执行引擎接收到的值赋值给工作内存的变量。
- store（存储）：作用于工作内存的变量，把工作内存中的一个变量的值传送到主内存中，以便以后的write操作。
- write（写入）：作用于主内存的变量，它把store操作从工作内存中一个变量的值传送到主内存的变量中。
同步规则
- 如果要把一个变量从主内存中复制到工作内存，就需要按顺序地执行read和load操作，如果把变量从工作内存中同步回主内存中，就要按顺序地执行store和write操作。但java内存模型只要求上述操作必须按顺序执行，而没有保证必须是连续执行。
- 不允许read和load、store和write操作之一单独出现
- 不允许一个线程丢弃它的最近assign的操作，即变量在工作内存中改变了之后必须同步到主内存中
- 不允许一个线程无原因地（没有发生过任何assign操作）把数据从工作内存同步回主内存中。
- 一个新的变量只能在主内存中诞生，不允许在工作内存中直接使用一个未被初始化（load或assign）的变量。即就是对一个变量实施use和store操作之前，必须先执行过了assign和load操作。
- 一个变量在同一时刻只允许一条线程对其进行lock操作，但lock操作可以被同一条线程重复执行多次，多次执行lock后，只有执行相同次数的unlock操作，变量才会被解锁。lock和unlock必须成对出现。
- 如果一个变量执行lock操作，将会清空工作内存中此变量的值，在执行引擎使用这个变量前需要重新执行load或assign操作初始化变量的值
- 如果一个变量事先没有被lock操作锁定，则不允许对它执行unlock操作；也不允许去unlock一个被其他线程锁定的变量。
- 对一个变量执行unlock操作之前，必须先把此变量同步到主内存中（执行store和write操作）。
并发优势
- 速度：同时处理多个请求，响应更快；复杂的操作可以分成多个进程同时进行
- 设计：程序设计在某些情况下更简单，也可以有更多的选择。
- 资源利用：cup能够在等待io的时候做一些其他的事情
并发风险
- 安全性：多个线程共享数据时可能会产生与期望不符的结果
- 活跃性：某个操作无法继续进行下去时，就会发生活跃性问题。比如死锁，饥饿等问题
- 性能：线程过多时会使得CPU频繁切换，调度时间增多，同步机制，消耗过多内存
Read All

21/58

Welcome to My Blog!

尚硅谷JUC

什么是JUC

进程与线程

（MK）并发编程精讲

线程八大核心基础

多线程实现方式

启动线程正确方式

正确停止线程

（MK）并发编程入门与高并发

概念

内存模型

同步操作

同步规则

并发优势

并发风险