Java基础 --- 多线程JUC，以及一些常用的设计模式总结

一、多线程

1、线程和进程的区别

进程是操作系统资源分配的基本单位，而线程是处理器任务调度和执行的基本单位， 一个进程可以运行多个线程

多进程：操作系统中同时运行的多个程序
多线程：在同一个进程中同时运行的多个任务

2、创建多线程的四种方式

Runnable和Callable是一个函数式接口：函数式接口是一个只包含有一个抽象方法的接口，可以用lambda表达式
第一种方法 继承Thread类：

class MyThread extends Thread{
     @Override
    public void run() {
        System.out.println("线程1");
    }
}
MyThread thread1 = new MyThread();

第二种方法 实现Runnable接口：

class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("线程1");
    }
}
MyRunnable r = new MyRunnable;
new Thread(r).start;
// 或者可以用lambda表达式
new Thread(() -> {
    System.out.println("线程1");
}).start;

第三种方法 实现Callable接口,结合 FutureTask：

class MyCallable implements Callable<String>{
     @Override
        public String call() throws Exception {
            return "Result from MyCallable";
        }
}
MyCallable myCallable = new MyCallable();
   FutureTask<String> futureTask = new FutureTask<>(myCallable);
   Thread thread = new Thread(futureTask);
   thread.start();
   // 接收返回值
   String result = futureTask.get();

第四种方法 使用线程池 ExecutorService：

ExecutorService executorService = Executors.newFixedThreadPool(5)

3、集合中的线程安全

ArrayList，HashSet, HashMap都不是线程安全的 如果多个线程同时对这些集合进行操作，可能会导致数据不一致、丢失更新等问题
要解决这些集合的线程安全问题，可以采取以下几种常见的方法：

1. 使用线程安全的集合类：ArrayList 替代类 Vector，HashMap 替代类 HashTable（这两个都是线程安全的，但效率不高）
2. 通过 Collections 类的同步包装方法：可以使用 Collections.synchronizedList(new ArrayList<>()) 来获取线程安全的 ArrayList
   对于HashSet和HashMap，也有相应的同步包装方法（但是效率也不高）
3. 使用并发集合类： List 替代类 CopyOnWriteArrayList， Set 替代类 CopyOnWriteArraySet， Map 替代类 ConcurrentHashMap（这都是线程安全的，而且效率也高）

二、设计模式

设计模式：代码在编写的时候总有一些规律，这些规律在总结之后，变成了设计者模式

1、单例模式

单例模式有两种 一种是饿汉模式 一种是懒汉模式

饿汉模式：在类加载时就创建实例，因为实例在类加载时就已经创建好，所以线程安全

class Girl{
    private static Girl girl = new Girl();
    // 无参的构造方法
    private Girl(){
        System.out.println("我是一个女孩");
    }
    public static Girl creatGirl(){
        return girl;
    }
}
public class code5 {
    public static void main(String[] args) {
        Girl girl1 = Girl.creatGirl();
        Girl girl2 = Girl.creatGirl();
        System.out.println(girl1==girl2);
    }
}
// 控制台输出：我是一个女孩
//           true

懒汉模式：在第一次使用实例时才创建实例，由于不是在类加载时创建实例，存在线程安全问题

class Boy{    private static Boy boy = null;
    private Boy(){
        System.out.println("我是一个男孩");
    }
    // 如果有多个线程同时调用这个方法，偶尔会出现对象被创建多次的情况(所以线程不安全),需要添加一个锁
    public synchronized static Boy creatBoy(){
        if (boy == null){
            boy = new Boy();
        }
        return boy;
    }
}
public class code5 {
    public static void main(String[] args) {
        Boy boy1 = Boy.creatBoy();
        Boy boy2 = Boy.creatBoy();
        System.out.println(boy1 == boy2);
    }
}
// 控制台输出：我是一个男孩
//           true

2、装饰者模式（IO流 缓冲流）

FileReader fileReader = new FileReader(newFile("C:\\Users\\admin\\Desktop\\source.txt"));
BufferedReader br = new BufferedReader(fileReader);

3、适配器模式

一些接口不太适合后面的实现类，需要稍加改进，这个时候我们可以实现一个中间类，完成桥接的或者过渡的作用，这种设计模式，就称之为适配器模式

interface inter{
    void eat();
    void sleep();
    void play();
    void run();
    void study();
}
// 实现类 （也就是适配器类）
class impl implements inter{
    @Override
    public void eat() {
    }
    @Override
    public void sleep() {
    }
    @Override
    public void play() {
    }
    @Override
    public void run() {
    }
    @Override
    public void study() {
    }
}
class Dog extends impl{
    @Override
    public void run() {
        System.out.println("狗狗奔跑");
    }
}
class Person extends impl{
    @Override
    public void study() {
        System.out.println("人在学习");
    }
}
public class code6 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        // 接口的多态
        inter person = new Person();
        dog.run();
        person.study();
    }
}
// 控制台输出：狗狗奔跑
//           人在学习

4、模板模式

1、需要父子关系
2、将多个子类中共有的方法抽取出来，变为父类的代码（实现）
3、多个子类不同的方法可以在子类中单独实现。

import java.math.BigInteger;

abstract class FuClass{

    private String role;

    public FuClass(String role) {
        this.role = role;
    }

    public abstract void zuoti();

    public void compluteTime(){
        long beginTime = System.currentTimeMillis();
        zuoti();
        long endTime = System.currentTimeMillis();
        System.out.println(role+"，做题花费了"+(endTime - beginTime));
    }
}

class Student2 extends FuClass{

    public Student2(String role) {
        super(role);
    }

    @Override
    public void zuoti() {
        long sum = 0;
        for (int i = 0; i < 200000; i++) {
            sum += i;
            //System.out.println(sum);
        }
        System.out.println("学生："+sum);
    }
}

class Teacher2 extends FuClass{

    public Teacher2(String role) {
        super(role);
    }

    @Override
    public void zuoti() {
        BigInteger sum = new BigInteger("1");
        for (int i = 1; i < 1000; i++) {
            sum = sum.multiply(new BigInteger(i+""));
        }
        System.out.println("老师："+sum);
    }
}
public class Demo11 {

    public static void main(String[] args) {
        Student2 student2 = new Student2("学生");
        student2.compluteTime();
        Teacher2 teacher2 = new Teacher2("老师");
        teacher2.compluteTime();
    }
}