进程与线程

继承Thread类

自定义线程类继承Thread类

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

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

• 子类继承Thread类具备多线程能力
• 启动线程：子类对象.start()
• 不建议使用：避免oop单继承局限性

public class StartThread1 extends Thread{
//线程的入口点
@Override
public void run(){
//线程体
for(int i=0;i<20;i++){
System.out.println("我在听课"+i);
    }
}


 public static void main(String[] args) {
        //main线程，主线程      
         //创建一个线程对象
          StartThread1 t = new StartThread1();
        //调用start()方法开启线程
        t.start();

        for(int i=0;i<2000;i++){
            System.out.println("我在学多线程"+i);
            }

    }


//线程不一定立即执行，CPU安排调度
}

实现Runnable接口

定义MyRunnable类实现Runnable接口

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

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

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

 StartThread st=new  StartThread();//一份资源

//多个代理，起不同的名字

new Thread(st,name:"小明").start();

new Thread(st,name:"老师").start();

new Thread(st,name:"小红").start();

public class StartThread implements Runnable{

    @Override
   public void run(){
     //run方法线程体
    for(int i=0;i<20;i++)  {
        System.out.println("我在听课"+i);}
    }

    public static void main(String[] args) {
        //创建runnable接口的实现类对象
        StartThread st=new  StartThread();

        //创建线程对象，通过线程对象来开启我们的线程，代理类对象
        Thread thread=new Thread(st);

        //启动
        thread.start();
   //  new Thread(st).start();相当于 Thread thread=new Thread(st);和thread.start();作用
      
       for(int i=0;i<200;i++)  {
        System.out.println("我在看代码"+i);
            }
        
    }

}

 乌龟赛跑的例子

//模型建立：赛道距离，判断比赛是否结束， 打印胜者，龟兔赛跑开始，模拟兔子睡觉

public class RabbitAndTurtle implements Runnable{
    private static String winner;
    @Override
    public void run() {

        for (int i = 1; i <= 100 ; i++) {
            //模拟兔子睡觉
            if (Thread.currentThread().getName().equals("兔子")&&i%10 == 0){
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //判断比赛是否结束
            boolean flag = gameOver(i);
            if (flag){
                break;
            }
            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("胜利者是"+winner);
            return true;
        }
        return false;
    }

    public static void main(String[] args) {
        RabbitAndTurtle rabbitAndTurtle = new RabbitAndTurtle();

        new Thread(rabbitAndTurtle,"兔子").start();
        new Thread(rabbitAndTurtle,"乌龟").start();
    }
}

多线程：静态代理模式

package demolyt;
//静态代理模式总结：
//真实对象和代理对象都要实现同一个接口
//代理对象要代理真实角色
//代理对象可以做很多真实对象做不了的事情
//真实对象专注做自己的事情
public class StacticProxy {
    public static void main(String[] args) {
        You you = new You();//你要结婚
        new Thread(()-> System.out.println("我爱你")).start();


//        WeddingCompany weddingCompany=new WeddingCompany(you);
//        weddingCompany.HappyMarry();
        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;
    }
    @Override
    public void HappyMarry() {
        before();
        this.target.HappyMarry();//这就是真实对象
        after();
    }
   private void before(){
       System.out.println("结婚之前，布置现场");
    }
    private void after(){
        System.out.println("结婚之后，收尾款");
    }
}