Day10:多线程的学习1

多线程

程序,进程,(多)线程

程序:指令和数据的有序集合,静态

进程:执行一次程序,动态,是系统资源分配的单位

线程:运行一次进程实质上是运行线程,而进程至少有一个线程,是CPU调度和执行的单位

多线程:有多个CPU才是真正的多线程,只有一个CPU的那种是因为切换速度快,看起来是多线程

核心概念

Thread

启用步骤

1. 自定义线程类继承Thread类
2. 重写run(),以及编写执行体
3. 创建线程对象,调用start()启动线程

注意:线程开启不一定立即执行,由CPU调度

实战例子

//第一步
public class thread01 extends Thread {
    //第二步
    @Override
    public void run() {
        for (int i = 0; i <200 ; i++) {
            System.out.println("第"+(i+1)+"次---run");
        }
    }
    
public static void main(String[] args) {
        //第三步
        thread01 thread01 = new thread01();
        thread01.start();
        for (int i = 0; i <10 ; i++) {
            System.out.println("第"+(i+1)+"次---主程序");
        }
    }

结果:可见主程序中夹杂着run()方法,实现了多线程

runable接口

Thread是继承,而runable是接口,只不过runable还是要用到Thread

代码实战:龟兔赛跑

public class race implements Runnable {
    private static String winner;//定义胜利者
    @Override
    public void run() {
        for (int i = 0; i<= 100; i++) {
        //判断是否满100步,打破循环
            boolean flag=gameover(i);
            if (flag){
                break;
            }
            if (Thread.currentThread().getName()=="兔子"&&i>=40){//当前行的方法可读出名字
                i=40;//模拟睡觉
            }
            System.out.println(Thread.currentThread().getName()+"跑了"+i+"步");
        }
    }
    private boolean gameover(int steps){
        if(winner!=null){
            return true;
        }
        if (steps==100){//打印出胜利者
            winner=Thread.currentThread().getName();       
               System.out.println("winneris"+Thread.currentThread().getName());
            return true;
        }
        return false;
    }
    public static void main(String[] args) {
        race x = new race();
        new Thread(x,"兔子").start();
        new Thread(x,"乌龟").start();
    }
}
//如果出现竞争,可能会出现并发现象,线程不安全,紊乱

小结:Thread与runable的区别

扩充:callable接口

点击跳转,第8课

静态代理模式

public class StaticProxy {
    public static void main(String[] args) {
    //创建新对象的同时,输入新创建的you()并启动接口
        new WeddingCompany(new you()).happyMarry();
    }
}
interface Marry{//接口
    void happyMarry();
}
class you implements Marry{//真实对象
    @Override
    public void happyMarry() {
        System.out.println("你要结婚了");
    }
}
class WeddingCompany implements Marry{//代理对象
    private Marry target;
    public WeddingCompany(Marry target){//构造方法
        this.target=target;
    }
        public void happyMarry(){
            before();
            this.target.happyMarry();
            after();
        }
    private void before(){
        System.out.println("布置现场,活跃气氛");
    }
    private void after(){
        System.out.println("结款");
    }
}

静态代理模式总结:

1.有真实对象和代理对象,且实现同一个接口

2.代理对象代理真实对的原因代理对象能做到真实对象做不到的事,从而让真实对象更专注的实现接口

3.由上例子看出,代理对象WeddingCompany相当于Thread,而happyMarry()相当于start().