Java-多线程详解（1）

目录

核心概念

线程创建

静态代理

Lambda表达式

---

核心概念

• 在操作系统中运行的程序就是进程process

• 一个进程可以有多个线程Thread

• 线程就是独立的执行路径

• 程序运行时，即使没有自己创建线程，后台也会有多个线程，例如主线程main（），gc线程

• 对同一份资源操作时，会存在资源抢夺的问题，需要加入并非控制

• 线程会带来额外的开销，如CPU调度时间，并发控制开销

• 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致

线程创建

两种方式：

1. Thread类

         自定义线程类继承Thread类

         重写run方法，编写线程执行体

         创建线程对象，调用start方法启动线程.  注意：线程开始不一定立即执行，由CPU调度执行

public class ThreadDemo extends Thread{
    public void run(){
        for (int i = 0; i < 20; i++) {
            System.out.println("我在学习多线程");
        }
    }
    //主线程
    public static void main(String[] args) {
        ThreadDemo threadDemo = new ThreadDemo();
        threadDemo.start();

        for (int i = 0; i < 20; i++) {
            System.out.println("我是主线程");
        }

    }
}

     2.  Runnable接口

          定义类实现Runnable接口

          实现run方法，编写线程执行体

         创建线程对象，调用start方法启动线程

public class RunnableDemo implements Runnable{
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("我在学习多线程");
        }
    }

    public static void main(String[] args) {
        RunnableDemo rd = new RunnableDemo();
        new Thread(rd).start();;

        for (int i = 0; i < 20; i++) {
            System.out.println("我是主线程");
        }
    }
}

静态代理

真实对象和代理对象都要实现同一个接口，代理对象要代理真实角色

好处：代理对象可以做很多真实对象做不了的事情，真实对象专注做自己的事情

public class StaticProxy {
    public static void main(String[] args) {
        WeddingCompany weddingCompany = new WeddingCompany(new You());
        weddingCompany.HappyMarry();

    }
}

//定义结婚接口
interface Marry{
    public  void HappyMarry();
}

//真实角色，你去结婚
class You implements Marry{
    public void  HappyMarry(){
        System.out.println("我要结婚了，我很高兴!!!");
    }
}

class WeddingCompany implements Marry{
    private  Marry target;//结婚客户
    public WeddingCompany(Marry target){
        this.target = target;
    }

    @Override
    public void HappyMarry() {
        System.out.println("结婚前，置办场地");
        this.target.HappyMarry();
        System.out.println("结婚后，收尾款");
    }
}

Lambda表达式

• 避免匿名内部类定义过多
• 实质属于函数式编程的概念

函数式接口：

• 任何接口，如果只包含唯一一个抽象方法，那么他就是一个函数式接口
• 对于函数式接口，可以通过Lambda表达式来创建接口的对象

public class LambdaDemo {
    //静态内部类
    static  class Love2 implements Love{
        public void love() {
            System.out.println("love2");
        }
    }

    public static void main(String[] args) {
        //匿名内部类
        Love love4 = new Love() {
            @Override
            public void love() {
                System.out.println("love4");
            }
        };

        //Lambad表达式
        Love love5 = ()->{
            System.out.println("love5");
        };
        //简化形式
        //1.简化参数类型,假如方法中有参数int a，可简化为a
        love5 = ()->{
            System.out.println("love5");
        };
        //2.简化花括号
        love5 = ()-> System.out.println("love5");;

    }
    //局部内部类
        class Love3 implements Love{
            public void love() {
                System.out.println("love3");
            }
    }
}

//函数式接口
interface Love{
    void love();
}

class Love1 implements Love{

    public void love() {
        System.out.println("love1");
    }
}

总结：
        lambda表达式只能有一行代码的情况下才能简化成为一行 ，如果有多行，那么就用代码块包裹，前提接口必须是函数式接口 多个参数也可以去掉参数类型，要去掉都去掉，必须加上括号.