多线程详解

一、简介

多线程核心概念：

普通方法调用线程：

注意：线程启动不一定立即执行，由cpu调度执行

二、创建线程

线程的三种创建方式：
实现runnable接口，继承线程（thread）类，实现callable接口

方法一：继承线程（thread）类：

//创建线程的方法1：继承thread类，调用start启动线程
//注意：线程启动不一定立即执行，由cpu调度执行
public class Thread1 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("线程-------"+i);
        }
    }

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

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

方法二：实现runnable接口，创建线程对象，通过线程对象来开启我们的线程

//创建线程方式2：实现runable接口，重写run方法执行线程需要丢入runnable接口实现类，调用start方法
public class thread2 implements Runnable{
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("线程-------"+i);
        }
    }

    public static void main(String[] args) {
        //创建thread实现类的对象
        thread2 t=new thread2();
        //创建线程对象，通过线程对象来开启我们的线程，代理
        new Thread(t).start();

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

小结：

三、初识并发问题

//初始并发问题
//多个 线程操作同一个对象，买火车票例子
//问题：多个线程操作同一个对象时，线程不安全，数据紊乱
public class thread3 implements Runnable{
    //票数
    private int TicketNms=10;

    public void run() {
        while (true){
            if (TicketNms <= 0 ) {
                break;
            }
            System.out.println(Thread.currentThread().getName()+"拿到了第"+TicketNms--+"张票");
        }
    }

    public static void main(String[] args) {
        thread3 thread3=new thread3();
        try {
            //延时
            Thread.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //多个线程操作一个对象
        new Thread(thread3,"小红").start();
        new Thread(thread3,"小米").start();
        new Thread(thread3,"小李").start();
    }
}

四、静态代理

//静态代理模式总结：真实对象和代理对象都要实现同一个接口
//代理对象要代理真实角色
//好吃：代理对象可以做真实对象做不了的事情，真实对象负责其他专门的事情
public class staticProxy {
    public static void main(String[] args) {
        winddyCompty winddyCompty=new winddyCompty(new you());
        winddyCompty.HappyMarry();
    }
}

//结婚
interface mamerry{
    void HappyMarry();
}

//你结婚
//真实目标角色
class you implements mamerry{
    public void HappyMarry() {
        System.out.println("你结婚了");
    }
}

//代理对象
class winddyCompty implements mamerry{

    private mamerry target;
    public winddyCompty(mamerry target){
        this.target=target;
    }
    public void HappyMarry() {
        befor();
        this.target.HappyMarry();
        after();
    }
    public void befor(){
        System.out.println("结婚前");
    }
    public void after(){
        System.out.println("结婚后");
    }
}

五、lambda表达式

//推导lambda表达式
public class thread4 {
    //静态内部类
    static class Ilike2 implements Ilike{

        public void lambda() {
            System.out.println("===== I like lambda");
        }
    }
    public static void main(String[] args) {
        Ilike ilike=new ilik();
        ilike.lambda();

        ilike=new Ilike2();
        ilike.lambda();

        //局部内部类
        class Ilike3 implements Ilike{
            public void lambda() {
                System.out.println("------ I like lambda");
            }
        }
        ilike=new Ilike3();
        ilike.lambda();

        ilike=new Ilike() {
            public void lambda() {
                System.out.println("===== I like lambda=====");
            }
        };
        ilike.lambda();

        //用lambda简化
        ilike =() ->{
            System.out.println("===== I like lambda=====");
        };
        ilike.lambda();

    }

}

interface Ilike{
    //定义一个函数式接口(一个接口只包含一个抽象方法)
 void lambda();
}

//实现类
class  ilik implements Ilike{

    public void lambda() {
        System.out.println("I like lambda");
    }
}

六、线程状态

七、线程方法