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

文章目录

  • 一、多线程
    • 1、线程和进程的区别
    • 2、创建多线程的四种方式
    • 3、集合中的线程安全
  • 二、设计模式
    • 1、单例模式
    • 2、装饰者模式(IO流 缓冲流)
    • 3、适配器模式
    • 4、模板模式


一、多线程

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();
    }
}

你可能感兴趣的:(java,设计模式)