多线程笔记

最新推荐文章于 2024-04-15 15:50:11 发布

求道者Ellis

最新推荐文章于 2024-04-15 15:50:11 发布

阅读量1.3k

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/Ellis_Biety/article/details/119121046

版权

这篇笔记详细介绍了Java中创建线程的三种方法，包括继承Thread类、实现Runnable接口和Callable接口，并通过下载网络图片进行实战演示。此外，还深入探讨了线程状态、静态代理、Lambda表达式、线程同步机制如synchronized和ReentrantLock，以及线程通信的管程法。

摘要由CSDN通过智能技术生成

一.创建线程的三种方法

1.继承thread类

    /**
     * 创建方式一,继承Thread类
     */
    @Override
    public void run() {
   
        for (int i = 0; i < 20; i++) {
   
            System.out.println("我在看代码---"+i);
        }
    }
    public static void main(String[] args) {
   
        //创建线程对象
        TestThread1 testThread1 = new TestThread1();
        //开启线程
        testThread1.start();
        for (int i = 0; i < 20; i++) {
   
            System.out.println("我在学习多线程---"+i);
        }
    }
}

2.实现runnable接口

	/**
	 * 创建线程方式2，实现Runnable接口
	 */
    @Override
    public void run() {
   
        for (int i = 0; i < 20; i++) {
   
            System.out.println("子线程启动"+i);
        }
    }

    public static void main(String[] args) {
   
        TestRunnable testRunnable = new TestRunnable();
        new Thread(testRunnable).start();
        for (int i = 0; i < 20; i++) {
   
            System.out.println("主线程启动"+i);
        }
    }
}

3.实现Callable接口

4.下载网络图片

package com.zhao.www.thread;

import java.io.IOException;

public class Downloader implements Runnable {
   

    private String url;
    private String name;

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

    @Override
    public void run() {
   
        WebDownloader webDownloader = new WebDownloader();
        try {
   
            webDownloader.downloader(url, name);
            System.out.println("下载了文件名：" + name);
        } catch (IOException e) {
   
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
   
        Downloader d1 = new Downloader("https://i0.hdslb.com/bfs/sycp/creative_img/202012/625fd761428be531b5405815ea33768b.jpg", "第一个.jpg");
        Downloader d2 = new Downloader("https://i0.hdslb.com/bfs/sycp/creative_img/202102/d521778b3f50444d90e6fefc6719065c.jpg", "第二个.jpg");
        Downloader d3 = new Downloader("https://i0.hdslb.com/bfs/activity-plat/static/20200714/953d0bfef678072bd11ec5fb6ff04190/nMOp2aGOf.png@400w_413h_1c_100q.webp", "第三个.jpg");

        new Thread(d1).start();
        new Thread(d2).start();
        new Thread(d3).start();
    }
}

5.小结

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

二.静态代理

1.经典案例房屋出租

package com.zhao.www.thread;

public class StaticProxy {
   
    public interface HouseSubject{
   
        public void rentHouse();
    }
    public static class RealHouseSubject implements HouseSubject{
   
        @Override
        public void rentHouse() {
   
            System.out.println("我是房主，卖房子");
        }
    }
    public static class HouseProxy implements HouseSubject{
   
        @Override
        public void rentHouse() {
   
            //广告
            this.ad();

            //创建房屋主人，让真实主人出租
            RealHouseSubject realHouseSubject = new RealHouseSubject();
            realHouseSubject.rentHouse();

            //卖出房子之后撤销广告
            this.backad();
        }
        private void ad(){
   
            System.out.println("广告，出租");
        }
        private void backad(){
   
            System.out.println("房子已经出租，撤销广告");
        }
    }
    public static class User {
   
        public static void main(String[] args) {
   
            HouseProxy proxy = new HouseProxy();
            proxy.rentHouse();
        }
    }
}

2.婚庆公司

package com.draco.proxystatic;

/**
 * 静态代理
 */
public class Test {
   

    public static void main(String[] args) {
   
        You you = new You();
        WeddingCompany weddingCompany = new WeddingCompany(you);
        weddingCompany.marry();
    }

}

interface Marry{
   
    void marry();
}

//真实对象：结婚的人
class You implements Marry{
   

    @Override
    public void marry() {
   
        System.out.println("小明准备结婚了！");
    }
}

//代理对象：婚庆公司
class WeddingCompany implements Marry{
   

    private You you;

    public WeddingCompany(You you) {
   
        this.you = you;
    }

    @Override
    public void marry() {
   
        before();
        you.marry();
        after();
    }

    private void after() {
   
        System.out.println("婚庆公司在结婚之后，收钱~");
    }

    private void before() {
   
        System.out.println("婚庆公司在结婚之前，准备布置~");
    }
}

三.lambda表达式

1.逐渐演进的版本

package com.draco.lambda;

public class TestLambda1 {
   

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

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

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

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

        like = new Like3();
        like.like();

        //5.匿名内部类
        like = new ILike() {
   
            @Override
            public void like() {
   
                System.out.println("lambda like 4");
            }
        };
        like.like();

        //6.lambda表达式
        like = ()->{
   System.out.println(