多线程（2）_随笔

多线程（2）多线程（2）

package thread;

public class RaceBetweenRabbitAndTortoise implements Runnable{

    //模拟龟兔赛跑
    private static String winner;
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            //模拟休息
            if (Thread.currentThread().getName().equals("兔子")&&i%10==0) {
                try {
                    Thread.sleep(1);
                } 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 is" + winner);
                return true;
            }
        }
        return false;
    }

    public static void main(String[] args) {
        RaceBetweenRabbitAndTortoise race = new RaceBetweenRabbitAndTortoise();
        new Thread(race,"兔子").start();
        new Thread(race,"乌龟").start();
    }
}

实现Callable接口

实现Callable接口，需要返回值类型
重写call方法，需要抛出异常
创建目标对象
创建执行服务:ExecutorService ser = Executors.newFixedThreadPool(1);
提交执行:Future result1 = ser.submit(t1);
获取结果:boolean r1 = result1.get()
关闭服务:ser.shutdownNow();

package thread.Demo02;

import thread.Demo01.WebDownloader;

import java.util.concurrent.*;

//线程创建方式三：实现Callable接口
public class TestCallable implements Callable {
    private String url;
    private String name;

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

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        TestCallable t1 = new TestCallable("https://tse1-mm.cn.bing.net/th/id/R-C.33d0949ed1d018fbd23b9264027e58e0?rik=XYcoHb%2foHS2aFw&riu=http%3a%2f%2fwww.desktx.com%2fd%2ffile%2fwallpaper%2fscenery%2f20170120%2fdf204ebd7a4829933463e2989deb54c6.jpg&ehk=oIKu9Q7Dsgg8tGWfXQ%2fdcQBt4l%2f92jwsatz95dhd0oE%3d&risl=&pid=ImgRaw&r=0","2.png");
        TestCallable t2 = new TestCallable("https://www.wahaotu.com/uploads/allimg/201904/1555074510295049.jpg","1.png");
        TestCallable t3 = new TestCallable("https://tse1-mm.cn.bing.net/th/id/R-C.250f95855aec49c974acb36b3ed32571?rik=BgcOI1PX1fb%2bww&riu=http%3a%2f%2fwww.desktx.com%2fd%2ffile%2fwallpaper%2fscenery%2f20170120%2f387b1a5181ebeddbec90fd5f19e606ce.jpg&ehk=Feb%2bz1leZKOVuTS20av3z7LKELRP0HH277cc6aSrAeI%3d&risl=&pid=ImgRaw&r=0","3.png");
        ExecutorService ser = Executors.newFixedThreadPool(3);

        Future r1 = ser.submit(t1);
        Future r2 = ser.submit(t2);
        Future r3 = ser.submit(t3);

        boolean re1 = r1.get();
        boolean re2 = r2.get();
        boolean re3 = r3.get();
        ser.shutdownNow();
    }
    @Override
    public Boolean call() {
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downLoader(url,name);
        System.out.println("下载了文件名为："+name);
        return true;
    }
}

静态代理

真实对象和代理对象都要实现同一个接口
代理对象要代理真实角色
代理对象可以做很多真实对象做不了的事情
真实对象专注做自己的事情

package StaticProxy;

public class Demo01 {
    public static void main(String[] args) {
        You you = new You();
        new Thread(()-> System.out.println("哈哈哈")).start();
        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 after() {
        System.out.println("收尾工作");
    }

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

Lambda表达式

为什么要用lambda表达式：

避免匿名内部类定义过多
可以让你的代码看起来很简洁
去掉了一堆没有意义的代码，只留下核心的逻辑。

函数式接口：

任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口。
对于函数式接口，我们可以通过lambda表达式来创建该接口的对象。

回顾几种类

package thread.Lambda;

public class TestLambda1 {
    //静态内部类
    static class Like2 implements ILike{
        @Override
        public void lambda() {
            System.out.println("这是第二个测试");
        }
    }

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

        like = new Like2();
        like.lambda();


        //局部内部类
        class Like3 implements ILike{
            @Override
            public void lambda() {
                System.out.println("这是第三个测试");
            }
        }
        like = new Like3();
        like.lambda();

        //匿名内部类
        like = new ILike() {
            @Override
            public void lambda() {
                System.out.println("这是第四个测试");
            }
        };
        like.lambda();

        //Lambda表达式
        like = ()-> {
            System.out.println("这是第五个测试");
        };
        like.lambda();
    }
}

//定义一个函数式接口
interface ILike{
    void lambda();
}

//接口的实现类
class Like implements ILike{
    @Override
    public void lambda() {
        System.out.println("这是一个测试");
    }
}

Lambda表达式直接使用

package thread.Lambda;

public class TestLambda2 {
    public static void main(String[] args) {
        //直接使用
        ILove love = (int a)->{
            System.out.println("颗粒儿辣舞"+a);
        };
        //简化一：去掉参数类型
        love = (a)->{
            System.out.println("颗粒儿辣舞"+a);
        };

        //简化二：去掉括号
        love = a -> {
            System.out.println("颗粒儿辣舞"+a);
        };

        //简化三:去掉花括号(如果花括号中要写多行代码时,花括号不能去掉)
        love = a -> System.out.println("颗粒儿辣舞"+a);
        love.love(1);
    }
}

interface ILove {
    void love(int a);
}

总结：

必须是函数式接口
多个参数也可以简化参数类型，保持统一的情况下必须要去掉就都去掉
多个参数时简化括号也不能用

线程状态

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vRZw5LTJ-1634556562018)(C:UsersLenovoPicturesSaved Pictures屏幕截图 2021-10-18 181611.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-q5yiBYWf-1634556562020)(C:UsersLenovoPicturesSaved Pictures屏幕截图 2021-10-18 181824.png)]

setPriority(int newPriority) 更改线程的优先级

static void sleep(long millis) 在指定的毫秒数内让当前正在执行的线程休眠

void join() 等待该线程终止

static void yield() 暂停当前正在执行的线程对象，并执行其他线程

void interrupt() 中断线程，别用这个方式

boolean isAlive() 测试线程是否处于活动状态

停止线程

不推荐使用JDK提供的stop()、destroy()方法。【已废弃】推荐线程自己停止下来
建议使用一个标志位进行终止变量
当flag=false，则终止线程运行。

package thread.State;

//测试stop
//1. 建议线程正常停止--->利用次数，不建议死循环
//2. 建议使用标志位--->设置一个标志位
//3. 不要使用stop和destroy等过时或者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("线程该停止了");
            }
        }
    }
}

线程休眠

sleep (时间)指定当前线程阻塞的毫秒数;
sleep存在异常InterruptedException;
sleep时间达到后线程进入就绪状态;
sleep可以模拟网络延时，倒计时等。
每一个对象都有一个锁,sleep不会释放锁;

package thread.State;

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

//模拟倒计时
public class TestSleep2 {
    public static void main(String[] args) throws InterruptedException {
        turnDown();

        //打印当前系统时间
        Date date = new Date(System.currentTimeMillis());//获取当前时间
        while (true){
            System.out.println(new SimpleDateFormat("HH:mm:ss").format(date));
            Thread.sleep(1000);
            date = new Date(System.currentTimeMillis());//更新时间
        }
    }


    public static void turnDown() throws InterruptedException {
        int num = 10;

        while(true){
            Thread.sleep(1000);
            System.out.println(num--);
            if (num<=0){
                break;
            }
        }
    }
}

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/zaji/4660985.html

多线程（2）

发表评论

评论列表（0条）