多线程管理

继承Thread类

Thread class	继承Thread类
Runnable接口	实现Runable接口
Callable接口	实现Callable接口

Thread

Thread thread=new Thread(this)//将this实例化为一个线程

• 自定义线程类继承Thread类
• 重写run()方法，编写线程执行体
• 创建线程对象，调用start()方法启动线程

//线程开启不一定执行，由CPU调度
public class TestThread1 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("我在看");
        }
    }

    public static void main(String[] args) {
        TestThread1 testThread1 = new TestThread1();
        testThread1.start();

        for (int i = 0; i < 20; i++) {
            System.out.println("学习");
        }
    }
}

实现Runnable

• 定义MyRunnable类实现Runnable接口
• 实现run()方法，编写线程执行体
• 创建线程对象，调用start()方法启动线程

public class TestThread2 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 2000; i++) {
            System.out.println("我在看");
        }
    }
    public static void main(String[] args) {
        TestThread2 testThread2 = new TestThread2();
        new Thread(testThread2).start();

        for (int i = 0; i < 2000; i++) {
            System.out.println("学习");
        }
    }
}

小结

1. 基础Thread类
   • 子类基础Thread类具备多线程能力
   • 启动线程：子类对象.start()
   • 不建议使用：避免OOP单继承局限性
2. 实现Runnable接口
   • 实现接口Runnable具有多线程能力
   • 启动线程：传入目标对象+Thread对象.start()
   • 推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用

Lamda表达式

• 为什么要用lambda表达式

  • 避免匿名内部类定义过多
  • 可以让你的代码看起来很简洁
  • 去掉了一堆没有意义的代码，只留下核心的逻辑

• 函数式接口的定义

  • 任何接口，如果只包含唯一一个抽象方法，那么他就是一个函数式接口。

    public interface Runnable{
    	public abstract void run();
    }
    

  • 对于函数式接口，我们可以通过lambda表达式来创建该接口的对象。

总结

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

//浅理解
like = ()->{//括号代表接口中的唯一的方法,下面是方法的代码体  赋值给like	
 System.out.println("学习");
}

public class Lamda {
    //3静态内部类
    static class Like2 implements  Ilike{

        @Override
        public void lambda() {
            System.out.println("i like lamda");
        }
    }
    public static void main(String[] args) {
        Like like = new Like();
        like.lambda();


        Like2 like2 = new Like2();
        like2.lambda();

        //4局部内部类
        class Like3 implements  Ilike{

            @Override
            public void lambda() {
                System.out.println("i like lamda3");
            }
        }
        Like3 like3 = new Like3();//前面的Like3可以不写
        like3.lambda();

        //5匿名内部类,没有类的名称，借助接口或者父类
        Ilike ilike = new Ilike() {
            @Override
            public void lambda() {
                System.out.println("i like lamda4");
            }
        };
        ilike.lambda();
        //6lamda简化
    }

}
//1接口
interface Ilike{
    void lambda();
}
//2实现类
class Like implements  Ilike{

    @Override
    public void lambda() {
        System.out.println("i like lamda");
    }
}