多线程详解第2讲：线程实现（重点）

悠悠 2021-09-07 11:22 375阅读 0赞

## 线程实现（重点） ##

### 目录 ###

*   *  线程实现（重点）
     *   *  1、三种创建方式
         *  2、Thread
         *  3、案例：下载图片
         *  4、实现Runnable接口
         *  5、小结
         *  6、初始并发问题
         *  7、龟兔赛跑
         *  8、实现Callable接口（了解即可）
         *  9、静态代理
         *  10、Lamda表达式

### 1、三种创建方式 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70]

### 2、Thread ###

> **学习提示：查看**JDK帮助文档

**步骤**

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

**代码**

package com.kaung.demo01;
    
    import java.awt.event.ItemEvent;
    
    //创建线程的方式一：继承Thread，重写run()方法，调用start开启线程
    
    //总结 ：注意 ，线程开启不一定立即执行，由cpu调度执行
    
    public class TestThread1 extends Thread{ 
        @Override
        public void  run(){ 
            //run方法线程体
            for(int i = 0; i < 20 ; i++){ 
                System.out.println("我在看代码---"+i);
            }
    
        }
        public static void main(String[] args) { 
            //main线程，主线程
    
            //创建一个线程对象
            TestThread1 testThread1 = new TestThread1();
    
            //调用start()方法开启线程,执行run方法
            testThread1.start();
            for(int i = 0; i < 20; i++){ 
                System.out.println("我在学习多线程---"+i);
            }
        }
    }

**执行结果**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 1]  
**主线程和run方法线程交替执行。**

### 3、案例：下载图片 ###

**代码**

package com.kaung.demo01;
    
    import org.apache.commons.io.FileUtils;
    
    import java.io.File;
    import java.io.IOException;
    import java.net.URL;
    
    //练习Thread ,实现多线程同步下载图片
    public class TestThread2 extends Thread{ 
        private String url; //网络图片地址
        private String name; //保存的文件名
        public TestThread2(String url,String name){ 
            this.url=url;
            this.name=name;
        }
        //下载图片线程执行体
        @Override
        public void run() { 
            WebDownloader webDownloader = new WebDownloader();
            webDownloader.downloader(url,name);
            System.out.println("下载了文件名为："+name);
        }
    
        public static void main(String[] args) { 
            TestThread2 t1 = new TestThread2("https://public-cdn-oss.mosoteach.cn/books/mobile/cover-1@2x.jpg","1.jpg");
            TestThread2 t2 = new TestThread2("https://public-cdn-oss.mosoteach.cn/books/mobile/cover-1@2x.jpg","2.jpg");
            TestThread2 t3 = new TestThread2("https://public-cdn-oss.mosoteach.cn/books/mobile/cover-1@2x.jpg","3.jpg");
            //先下载t1
            t1.start();
            //然后t1
            t2.start();
            //最后t3
            t3.start();
        }
    }
    //下载器
    class WebDownloader{ 
        //下载方法
        public void downloader(String url,String name){ 
            try { 
                FileUtils.copyURLToFile(new URL(url),new File(name));
            } catch (IOException e) { 
                e.printStackTrace();
                System.out.println("IO异常，downloader方法出现异常");
            }
        }
    
    }

**运行截图**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 2]  
我们开启了三个线程，这三个线程并不是按序执行的，谁先抢夺到了时间，谁先执行。

验证了结论：**在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能认为的干预的。**

### 4、实现Runnable接口 ###

**步骤**

1.  **定义MyRunnable类实现Runnable接口**
2.  **实现run()方法，编写线程执行体**
3.  **创建线程对象，调用start()方法启动线程**

**代码**

package com.kaung.demo01;
    
    public class TestThread3 implements Runnable{ 
        @Override
        public void  run(){ 
            //run方法线程体
            for(int i = 0; i < 20 ; i++){ 
                System.out.println("我在看代码---"+i);
            }
    
        }
        public static void main(String[] args) { 
    
            //创建runable接口的实现类对象
            TestThread3 testThread3 = new TestThread3();
            //创建线程对象，通过线程对象来开启我们的线程，代理
            Thread thread = new Thread(testThread3);
            thread.start();
    
            for(int i = 0; i < 200; i++){ 
                System.out.println("我在学习多线程---"+i);
            }
        }
    }

**推荐使用Runnable对象，因为Java单继承的局限性**

### 5、小结 ###

**继承Thread类**

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

**实现Runable接口**

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

### 6、初始并发问题 ###

**代码**

package com.kaung.demo01;
    //多个线程同时操作一个对象
    //买火车票的例子
    
    //发现问题 ： 多个线程操作同一个资源的情况下，线程不安全，数据紊乱。
    public class TestThread4 implements Runnable { 
        private int ticketNums = 10;
        @Override
        public void run() { 
            while(true){ 
                if((ticketNums<=0)){ 
                    break;
                }
                //模拟延时
                try { 
                    Thread.sleep(200);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"--->拿到了第"+ticketNums-- +"票");
            }
        }
    
        public static void main(String[] args) { 
            TestThread4 ticket = new TestThread4();
    
            new Thread(ticket,"小明").start();
            new Thread(ticket,"老师").start();
            new Thread(ticket,"黄牛党").start();
        }
    }

**运行截图**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 3]  
**发现问题 ： 多个线程操作同一个资源的情况下，线程不安全，数据紊乱。**

### 7、龟兔赛跑 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 4]  
**代码模拟**

package com.kaung.demo01;
    
    //模拟龟兔赛跑
    public class Race 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(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 is "+winner);
                return true;
            }
            return false;
        }
    
        public static void main(String[] args) { 
            Race race = new Race();
            new Thread(race,"兔子").start();
            new Thread(race,"乌龟").start();
        }
    }

### 8、实现Callable接口（了解即可） ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 5]

### 9、静态代理 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 6]  
**模式总结**

*  真实对象和代理对象都要实现同一个接口
 *  代理对象要代理真实对象

**好处**

*  代理对象可以做很多真实对象做不了的事情
 *  真实对象专注做自己的事情

**代码**

import sun.plugin2.main.client.WDonatePrivilege;
    
    //静态代理模式总结
    //真实对象和代理对象都要实现同一个接口
    //代理对象要代理真实对象
    
    //好处
        //代理对象可以做很多真实对象做不了的事情
        //真实对象专注做自己的事情
    public class StaticProxy { 
        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() { 
            brfore();
            this.target.HappyMarry(); //这就是真实对象
            after();
        }
    
        private void after() { 
            System.out.println("结婚之后，收尾款");
        }
    
        private void brfore() { 
            System.out.println("结婚之前，布置现场");
        }
    }

### 10、Lamda表达式 ###

*  **λ希腊字母表中排序第十一位的字母，英语名称为Lambda**
 *  **避免匿名内部类定义过多**
 *  **其实质属于函数式编程的概念**

new Thread（**()->System.out.println(“多线程学习。。。。”)**）.start()

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 7]  
**为什么要使用lambda表达式**

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

**也许你会说，我看了Lambda表达式，不但不觉得简洁，反而觉得更乱，看不懂了。那是因为我们还没有习惯，用的多了，看习惯了，就好了**

理解**Functional Interface**（函数式接口）是学习Java8 **lambda表达式**的关键所在

**函数式接口的定义：**

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

**代码推导lambda表达式**

package com.kuang.lambda;
    /* 推导lambda表达式 */
    public class TestLambda1 { 
        //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");
        }
    }

**代码2**

package com.kuang.lambda;
    
    public class TestLambda2 { 
        public static void main(String[] args) { 
    
            ILove love = (int a)->{ 
                System.out.println("I love you-->"+a);
            };
            love.love(520);
    
            //简化1 参数类型
            love = (a)->{ 
                System.out.println("I love you-->"+a);
            };
            love.love(521);
    
            //简化2 简化括号
            love = a->{ 
                System.out.println("I love you-->"+a);
            };
            love.love(522);
    
            //简化2 简化花括号
            love = a->System.out.println("I love you-->"+a);;
            love.love(523);
        }
    }
    //函数式接口
    interface ILove{ 
        void love(int a);
    }

**总结**

*  `lambda`表达式只能在有一行代码的情况下才能简化成一行，如果有多行，那么就用代码块包裹。
 *  前提是接口为**函数式接口** 。
 *  多个参数也可以去掉参数类型，要去掉就都去掉，必须加上括号。

**多线程详解系列文章目录**

[多线程详解第1讲：线程简介][1]

[多线程详解第2讲：线程实现（重点）][2]

[多线程详解第3讲：线程状态][3]

[多线程详解第4讲：线程同步（重点）][4]

[多线程详解第5讲：线程协作][5]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70]: /images/20210724/3e3091f07d494bcab3e13628c7d91ce4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 1]: /images/20210724/14ebd8e5664c4bd4a07e77b68c797ab0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 2]: /images/20210724/b9008c2cfc4343a7a290f6fa3d8c77cc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 3]: /images/20210724/c81e6e680c5e46ddad49669013debf7d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 4]: /images/20210724/30d5c2acf9ce4c178513f5fc7f158d7b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 5]: /images/20210724/f10a5266c0424a74ad980f3831ec297f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 6]: /images/20210724/dccbee2d559347bea109034d2e8b1fde.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTYyOTI4NQ_size_16_color_FFFFFF_t_70 7]: /images/20210724/428018bd6ad74159b06750315e29c2af.png
[1]: https://blog.csdn.net/weixin_45629285/article/details/116034361
[2]: https://blog.csdn.net/weixin_45629285/article/details/116034464
[3]: https://blog.csdn.net/weixin_45629285/article/details/116064500
[4]: https://blog.csdn.net/weixin_45629285/article/details/116065351
[5]: https://blog.csdn.net/weixin_45629285/article/details/116065982