实现线程的两种方式

继承Thread类

package thread;

public class ThreadTest extends Thread {
    //重写thread的run方法
    @Override
    public void run(){
        for(int i=0;i<100;i++){
            System.out.println("我是第"+i+"个");
        }
    }

    public static void main(String[] args) {
        //创建重写run的实体类
        ThreadTest threadTest = new ThreadTest();
        //调用thread的start方法
        threadTest.start();
    }
    
}

实现Runnable接口

package thread;

public class RunnableTest implements Runnable{
    //重写run方法
    @Override
    public void run(){
        for(int i=0;i<100;i++){
            System.out.println("我是第"+i+"个");
        }
    }

    public static void main(String[] args) {
        //创建重写run的实体类
        RunnableTest runnableTest = new RunnableTest();
        //传入目标对象，利用Thread调用线程
        new Thread(runnableTest).start();
        new Thread(runnableTest).start();
    }
}

为避免Java的单继承的缺点，建议使用Runnable接口

线程并发

多个线程对同一个资源进行处理，会造成并发冲突

静态代理模式

真实对象和代理对象要实现同一接口
代理对象要代理真实绝色

lamda表达式

为什么用lamda表达式？
-避免匿名内部类过多
-可以让代码简介
-只留下核心逻辑
-实际属于函数式编程（一个接口包含一个方法）

package thread;

public class Lambda {
    public static void main(String[] args) {
        /*class Like implements ILike{

            @Override
            public void lambda() {
                System.out.println("我喜欢你");
            }
        }*/


        /*ILike like = new ILike(){

            @Override
            public void lambda() {
                System.out.println("我喜欢你");
            }
        };*/
        ILike like = ()->{System.out.println("我喜欢你");};

        like.lambda();
    }
}
//函数型接口
interface ILike{
    void lambda();
}
###线程状态