多线程03

 

package com.thread.demo02;

import com.thread.demo01.TestThread2;

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.*;

//线程创建方式三：实现Callable接口
/*
callable的好处
1.可以定义返回值
2.可以抛出异常
 */
public class TestCallable implements Callable<Boolean> {
    private String url;
    private String name;

    public TestCallable(String url,String name){
        this.url=url;
        this.name=name;
    }

    //下载图片线程的执行体
    @Override
    public Boolean call() {
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url,name);
        System.out.println("下载了文件名为："+name);
        return true;
    }

    public static void main(String[] args) {
        TestCallable t1 = new TestCallable("https://t7.baidu.com/it/u=4198287529,2774471735&fm=193&f=GIF","1.jpg");
        TestCallable t2 = new TestCallable("https://t7.baidu.com/it/u=4198287529,2774471735&fm=193&f=GIF","2.jpg");
        TestCallable t3 = new TestCallable("https://t7.baidu.com/it/u=4198287529,2774471735&fm=193&f=GIF","3.jpg");

        //创建执行服务
        ExecutorService ser= Executors.newFixedThreadPool(3);

        //提交执行
        Future<Boolean> r1=ser.submit(t1);
        Future<Boolean> r2=ser.submit(t2);
        Future<Boolean> r3=ser.submit(t3);

        //获取结果
        try {
            boolean rs1=r1.get();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } catch (ExecutionException e) {
            throw new RuntimeException(e);
        }
        try {
            boolean rs2=r2.get();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } catch (ExecutionException e) {
            throw new RuntimeException(e);
        }
        try {
            boolean rs3=r3.get();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } catch (ExecutionException e) {
            throw new RuntimeException(e);
        }

        //关闭服务
        ser.shutdown();

    }

}
class WebDownloader{
    //下载方法
    public void downloader(String url,String name){
        try {
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
            System.out.println("IO异常，downloader方法出现异常");
            throw new RuntimeException(e);

        }
    }
}

 

静态处理：

package com.thread.demo03;

//静态代理模式总结
//真实对象和代理对象都要实现同一个接口
//代理对象要代理真实角色

//好处：
/*

    1.代理对象可以做好多真实对象做不了的事情
    2.真实对象专注做自己的事情
 */
public class StaticProxy {
    public static void main(String[] args) {
        You you = new You();//你要结婚
        WeddingCompant weddingCompant = new WeddingCompant(you);
        weddingCompant.HappyMarry();

    }
}
interface Marry{

    void HappyMarry();
}
//真实角色
class  You implements  Marry{
    @Override
    public void HappyMarry() {
        System.out.println("要结婚啦");
    }
}
//代理角色
class WeddingCompant implements Marry{
    public Marry target;//代理谁----》真实目标角色
    public WeddingCompant(Marry target) {
        this.target = target;
    }
    @Override
    public void HappyMarry() {
        before();
        this.target.HappyMarry();//这就是真是对象
        after();
    }

    private void after() {
        System.out.println("结婚之后收尾款");
    }

    private void before() {
        System.out.println("结婚前布置现场");
    }
}

 Lamada表达式：

package com.Lambda;
/*
推到Lambda公式
 */
public class TestLambda {

    //3.静态内部类
    static class Like2 implements ILike{
        @Override
        public void lambda() {
            System.out.println(" i like lambda2");
        }
    }

    public static void main(String[] args) {
        ILike Like = new Like();

        Like.lambda();

        Like=new Like2();

        Like.lambda();

        //4.局部内部类
        class Like3 implements ILike{
            @Override
            public void lambda() {
                System.out.println(" i like lambda3");
            }
        }
        Like=new Like3();
        Like.lambda();

        //5.匿名内部类,，没有类的名称，必须借助接口或者父类
        Like=new ILike() {
            @Override
            public void lambda() {
                System.out.println(" i like lambda4");

            }
        };
        Like.lambda();
        //6.用lambda简化
        Like=()->{
            System.out.println(" i like lambda5");

        };
        Like.lambda();



    }
}
//1.定义一个函数式接口
interface ILike{
    void lambda();
}
//2.实现类
class Like implements ILike{
    @Override
    public void lambda() {
        System.out.println(" i like lambda");
    }
}

package com.Lambda;

public class TestLambda2 {

    public static void main(String[] args) {


         Ilove love =(int a)->{
                System.out.println(" i love you--->"+a);
            };
        //简化1：参数类型
        love=(a)->{
            System.out.println(" i love you--->"+a);
        };
        love.love(3);
        //简化2：简化括号
        love=a->{
            System.out.println(" i love you--->"+a);
            System.out.println(" i love you--->"+a);

        };
        love.love(6);
        //简化2：去掉花括号
        love=a->System.out.println(" i love you--->"+a);

        /*
        总结：
        1.lambda表达式只能由一行代码的情况下 才能简化成一行
        多行 需要用代码块 即用花括号
        2.前提是接口是函数式接口（即接口只有一个方法）
        3.多个参数也可去掉参数类型 要去必须都去 要不去掉都不去掉
         */
        }

}


interface Ilove{
    void  love(int a);
}

 线程停止：

package com.state;


//测试stop
//1.建议线程正常停止--------》利用次数，不建议死循环
//2.建议使用标志位---->设置一个标志位
//3.不要使用stop或destory等过时或jdk不建议使用的方法
public class TestStop implements Runnable{

    //1.设置一个标志位
    private boolean flag=true;

    @Override
    public void run() {

        int i=0;
        while (flag){
            System.out.println("run........Thread"+i);
        }
    }

    //2.设置一个公开的方法停止线程，转换标志位
    public void stop(){
        this.flag=false;
    }
    public static void main(String[] args) {

        TestStop testStop = new TestStop();
        new Thread(testStop).start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("main"+i);
            if(i==900){
                //调用stop方法切换标志位，让线程停止
                testStop.stop();
                System.out.println("线程该停止啦");
            }
        }
    }
}

线程休眠：

 模拟延时：

package com.state;

import com.thread.demo01.TestThread4;
//模拟延时
public class TestSleep implements Runnable{

        //票数
        private  int ticketnums=10;

        @Override
        public void run() {
            while (true){
                if(ticketnums<=0){
                    break;
                }
                //模拟延时
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println(Thread.currentThread().getName()+"---->拿到了第"+ticketnums--+"票");

            }
        }

        public static void main(String[] args) {
            TestSleep ticket=new TestSleep();
            new Thread(ticket,"mao").start();
            new Thread(ticket,"mi").start();
            new Thread(ticket,"huanglao").start();
        }
    }

模拟计时：

package com.state;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.SimpleTimeZone;

//模拟倒计时
public class TestSleep2 {

    public static void tendown() throws InterruptedException {
        int num=10;
        while(true){
            Thread.sleep(1000);
            System.out.println(num--);
            if(num<=0){
                break;
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        tendown();
        //打印当前时间
        Date stratTime=new Date(System.currentTimeMillis());//获取系统当前时间

        while (true){
            Thread.sleep(1000);
            System.out.println(new SimpleDateFormat("HH:mm:ss").format(stratTime));
            stratTime=new Date(System.currentTimeMillis());
        }
    }
}

线程礼让：

package com.state;

//测试礼让线程
//礼让不一定成功，看cpu心情
public class TestYield {

    public static void main(String[] args) {
        MyYield myYield = new MyYield();
        new Thread(myYield,"a").start();
        new Thread(myYield,"b").start();
    }
}
class MyYield implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程开始执行");
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+"线程停止执行");
    }
}