Welcome to My Blog!

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

（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

BigDecimal精确计算

2019-10-22

百味皆苦

java基础

BigDecimal

简介
大小比较
保留小数
常用方法
运算工具类

简介

使用 BigDecimal 来定义浮点数的值，再进行浮点数的运算操作，解决浮点数运算精度丢失问题
我们在使用BigDecimal时，为了防止精度丢失，推荐使用它的 BigDecimal(String) 构造方法来创建对象。
BigDecimal 主要用来操作（大）浮点数，BigInteger 主要用来操作大整数（超过 long 类型）。
BigDecimal 的实现利用到了 BigInteger, 所不同的是 BigDecimal 加入了小数位的概念

大小比较

//a.compareTo(b) : 返回 -1 表示小于，0 表示 等于， 1表示 大于。
BigDecimal a = new BigDecimal("1.0");
BigDecimal b = new BigDecimal("0.9");
System.out.println(a.compareTo(b));// 1

保留小数

//通过 setScale方法设置保留几位小数以及保留规则。
BigDecimal m = new BigDecimal("1.255433");
BigDecimal n = m.setScale(3,BigDecimal.ROUND_HALF_DOWN);
System.out.println(n);// 1.255

常用方法

/**
 * 求余数
 * 返回值为 (this % divisor) 的 BigDecimal
 */
BigDecimal remainder(BigDecimal divisor);

/**
 * 求相反数
 * 返回值是 (-this) 的 BigDecimal
 */
BigDecimal negate();

/**
 * 将此 BigDecimal 与指定的 BigDecimal 比较
 * 根据此方法,值相等但具有不同标度的两个 BigDecimal 对象（如，2.0 和 2.00）被认为是相等的;
 * 相对六个 boolean 比较运算符 (<, ==, >, >=, !=, <=) 中每一个运算符的各个方法,优先提供此方法;
 * 建议使用以下语句执行上述比较：(x.compareTo(y) <op> 0), 其中 <op> 是六个比较运算符之一;
 *
 * 指定者：接口 Comparable<BigDecimal> 中的 compareTo
 * 返回：当此 BigDecimal 在数字上小于、等于或大于 val 时，返回 -1、0 或 1
 */
int compareTo(BigDecimal val);

运算工具类

import java.math.BigDecimal;

public class ArithUtil {

    // 除法运算默认精度  
    private static final int DEF_DIV_SCALE = 10;  
  
    private ArithUtil() {  
  
    }  
  
    /** 
     * 精确加法 
     */  
    public static double add(double value1, double value2) {  
        BigDecimal b1 = BigDecimal.valueOf(value1);  
        BigDecimal b2 = BigDecimal.valueOf(value2);  
        return b1.add(b2).doubleValue();  
    }  
  
    /** 
     * 精确减法 
     */  
    public static double sub(double value1, double value2) {  
        BigDecimal b1 = BigDecimal.valueOf(value1);  
        BigDecimal b2 = BigDecimal.valueOf(value2);  
        return b1.subtract(b2).doubleValue();  
    }  
  
    /** 
     * 精确乘法 
     */  
    public static double mul(double value1, double value2) {  
        BigDecimal b1 = BigDecimal.valueOf(value1);  
        BigDecimal b2 = BigDecimal.valueOf(value2);  
        return b1.multiply(b2).doubleValue();  
    }  
  
    /** 
     * 精确除法 使用默认精度 
     */  
    public static double div(double value1, double value2) throws IllegalAccessException {  
        return div(value1, value2, DEF_DIV_SCALE);  
    }  
  
    /** 
     * 精确除法 
     * @param scale 精度 
     */  
    public static double div(double value1, double value2, int scale) throws IllegalAccessException {  
        if(scale < 0) {  
            throw new IllegalAccessException("精确度不能小于0");  
        }  
        BigDecimal b1 = BigDecimal.valueOf(value1);  
        BigDecimal b2 = BigDecimal.valueOf(value2);  
        // return b1.divide(b2, scale).doubleValue();  
        return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();  
    }  
  
    /** 
     * 四舍五入 
     * @param scale 小数点后保留几位 
     */  
    public static double round(double v, int scale) throws IllegalAccessException {  
        return div(v, 1, scale);  
    }  
      
    /** 
     * 比较大小 
     */  
    public static boolean equalTo(BigDecimal b1, BigDecimal b2) {  
        if(b1 == null || b2 == null) {  
            return false;  
        }  
        return 0 == b1.compareTo(b2);  
    }  
    
    
    public static void main(String[] args) throws IllegalAccessException {
        double value1=1.2345678912311;
        double value2=9.1234567890123;
        BigDecimal value3=new BigDecimal(Double.toString(value1));
        BigDecimal value4=new BigDecimal(Double.toString(value2));
        System.out.println("精确加法================="+ArithUtil.add(value1, value2));
        System.out.println("精确减法================="+ArithUtil.sub(value1, value2));
        System.out.println("精确乘法================="+ArithUtil.mul(value1, value2));
        System.out.println("精确除法 使用默认精度 ================="+ArithUtil.div(value1, value2));
        System.out.println("精确除法  设置精度================="+ArithUtil.div(value1, value2,20));
        System.out.println("四舍五入   小数点后保留几位 ================="+ArithUtil.round(value1, 10));
        System.out.println("比较大小 ================="+ArithUtil.equalTo(value3, value4));
    }
}

Read All

21/58

Welcome to My Blog!

（MK）并发编程精讲

线程八大核心基础

多线程实现方式

启动线程正确方式

正确停止线程

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

概念

内存模型

同步操作

同步规则

并发优势

并发风险

BigDecimal精确计算

简介

大小比较

保留小数

常用方法

运算工具类