多线程

 

 

 

 推荐使用实现runnable 接口

/*创建线程方法一*/
public  class  Test03 extends  Thread{
    @Override
    public  void  run() {
        for (int i = 0; i <20 ; i++) {
            System.out.println("继承thread类");
        }
    }
    /*若调用run方法 则是先执行run方法
    *调用start 方法是多个线程同时执行(和CPU争抢资源 谁抢到了就运行谁的代码)
    * */
    public static void main(String[] args) {

       Test03 t=new Test03();
        t.start();
        //t.run();
        for (int i = 0; i < 200; i++) {
            System.out.println("我是主线程");
        }
    }
}

/*创建线程方法二 执行线程需要丢入runnable*/
public  class Test05 implements   Runnable{

    public void run() {
        for (int i = 0; i <10 ; i++) {
            System.out.println("实现runnable接口");
        }
    }

    public static void main(String[] args) {
       /* for (int i = 0; i <1000 ; i++) {
            System.out.println("主线程执行");
        }
        若循环放这里 会先执行循环 循环完了在执行下面的代码
        */

        Test05 test05 = new Test05();
       // test05.run();
        //通过线程对象开启线程
        Thread thread=new Thread(test05);//可以传一个实现了runnable接口的实现类  代理
        thread.start();
        for (int i = 0; i <1000 ; i++) {
            System.out.println("主线程执行");
        }
    }
}

import org.apache.commons.io.FileUtils;
public  class Test04 extends  Thread{
    private String url;
    private String file;
 public Test04(String url,String file){
     this.url=url;
     this.file=file;
 }
    @Override
    public  void  run() {
        System.out.println(currentThread().getName()+"继承重写run方法");
        WebDownloader webDownloader = new WebDownloader();
        try {
            webDownloader.DownLoader(url,file);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        Test04 t1 = new Test04("https://img1.baidu.com/it/u=2953170863,3813798922&fm=253&fmt=auto&app=138&f=PNG?w=500&h=314","f1.jpg");
        Test04 t2 = new Test04("https://img1.baidu.com/it/u=2953170863,3813798922&fm=253&fmt=auto&app=138&f=PNG?w=500&h=314","f2.jpg");
        Test04 t3 = new Test04("https://img1.baidu.com/it/u=2953170863,3813798922&fm=253&fmt=auto&app=138&f=PNG?w=500&h=314","f3.jpg");
        t1.start();
        t2.start();
        t3.start();
    }
}
class WebDownloader{
    public void DownLoader(String url,String file) throws IOException {
        FileUtils.copyURLToFile(new URL(url),new File(file));

    }
}

/*创建线程方法多线程抢票问题*/
public  class Test06 implements   Runnable {
    //票数
    private int ticketNum = 10;

    public  void run() {
        while (true) {
            if (ticketNum > 0) {
                try {
                    //多个线程操作同一个资源时不安全,线程紊乱
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "拿到了" + ticketNum-- + "张票");
            }
        }
    }
    public static void main(String[] args) {
        Test06 test06=new Test06();
        Thread t1=new Thread(test06,"小明");
        Thread t2=new Thread(test06,"小王");
        Thread t3=new Thread(test06,"小丽");
        t1.start();
        t2.start();
        t3.start();
    }
}

 

 

/*创建线程方法多线程同时操作同一个对象
* 多个线程操作同一个资源*/
public  class Test08 implements   Runnable {
    //胜利者
    private static String winner;
    private static int i;
    @SneakyThrows
    public void run() {
        System.out.println("开始执行run方法"+Thread.currentThread().getName());
        for (i = 0; i <= 100; i++) {
            if(Thread.currentThread().getName().equals("兔子")){
                Thread.sleep(200);
            }

            //判断比赛是否结束
            boolean flag=gameover(i);
            if(flag){
                //如果比赛结束了 就停止程序
                break;
            }
            System.out.println(Thread.currentThread().getName() + "跑了" + i + "步");
        }
    }
    //判断是否完成比赛
    private boolean gameover(int steps) {
        if (winner != null) {//已经有胜利者了
            return true;
        }
        else {
                if (steps == 100) {
                winner = Thread.currentThread().getName();
                System.out.println("winner is " + winner);
                return true;
                 }
        }
        return false;
    }
    public static void main(String[] args) {
        Test08 t=new Test08();
      new Thread(t,"乌龟").start();
      new Thread(t,"兔子").start();
    }
}

静态代理思想
//目标对象这代理对象都要实现同一个接口
//代理对象要代理真实角色,需要将被代理的角色当参数传入（有参构造）,作为代理对象的属性
public class StaticProxy {
interface Marry{
    void  HappyMarry();
}
static class Person implements Marry{
    public void HappyMarry() {
        System.out.println("张三开心的结婚了");
    }
}

static 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("结婚后洞房");
    }
}
    public static void main(String[] args) {
        WeddingCompany weddingCompany = new WeddingCompany(new Person());
        weddingCompany.HappyMarry();
    }
}

public class Lamda {

        /*静态内部类*/
   static class Like2 implements Ilike{
        public void like() {
            System.out.println("i like lamda2");
        }
    }
    public static void main(String[] args) {
        Ilike like = new Like();
        like.like();

        Ilike like2 = new Like2();
        like2.like();


        /*局部内部类*/
        class Like3 implements Ilike{
            public void like() {
                System.out.println("i like lamda3");
            }
    }
        Ilike like3 = new Like3();
        like3.like();
        /*匿名内部类*/
        Ilike like4 = new Ilike() {
            public void like() {
                System.out.println("i like lamda4");
            }
        };
        like4.like();

/*        *//*lamda*//*
        Ilike like5=()->{
            System.out.println("i like lamda5");
        };
    like5.like();*/
}
interface  Ilike{
    void like();
}

static class Like implements Ilike{
    public void like() {
        System.out.println("i like lamda");
    }
}}

public class TestLamda {
    /*静态内部类*/
    static class Love2 implements ILove{
        public void love(int a) {
            System.out.println("i love you"+a);
        }
    }

    public static void main(String[] args) {
        ILove iLove=new Love();
        iLove.love(1);

        Love2 love2 = new Love2();
        love2.love(2);

         class Love3 implements ILove{
            public void love(int a) {
                System.out.println("i love you"+a);
            }
        }

        ILove love3=new ILove() {
            public void love(int a) {
                System.out.println("i love you"+a);
            }
        };
        love3.love(3);

      /*  ILove love4=(int a)-> {
                System.out.println("i love you"+a);

        };
        love4.love(4);*/
      /*  *//*简化一  去掉返回值类型*//*
        ILove love4=(a)-> {
            System.out.println("i love you"+a);

        };*/

       /* *//*简化二 去掉花括号*//*
        ILove love4=a-> {
            System.out.println("i love you"+a);

        };*/
        /*去掉大括号*/
        /*总结lamda表达式只能有一行代码情况下才能简化成一行
        * 如果有多行就要用代码块包裹
        * 前提是接口为函数式接口
        * 多个参数也可以去掉参数类型 要去掉就都去掉
        * */
        ILove love5=a-> System.out.println("i love you"+a);

        love5.love(4);
    }
}


interface ILove{
    void love(int a);
}

class Love implements ILove{
    public void love(int a) {
        System.out.println("i love you"+a);
    }
}