Java多线程学习——01

最新推荐文章于 2024-09-10 10:21:38 发布

griefseed

最新推荐文章于 2024-09-10 10:21:38 发布

阅读量111

点赞数

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/griefseed/article/details/114266405

版权

java 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

Java多线程学习——01

1.核心概念

程序：是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念
进程Process：是执行程序的一次执行过程，它是一个动态的概念，是系统资源分配的单位、
通常在一个进程中可以包含若干个线程Thread，当然一个进程中至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的单位
线程就是独立的执行路径。在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程、gc线程；main()称之为主线程，为系统的入口，用于执行整个程序
在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为干预的。对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制。线程会带来额外的开销，如CPU调度时间，并发控制开销。每个线程在自己的工作内存交互，内存控制不当会造成数据不一致。

2.线程的创建

三种创建方式：Thread Class 继承Thread类

Runnable接口实现Runnable接口（重点）

Callable接口实现Callable接口（了解）
自定义线程类继承Thread类>>重写run()方法，编写线程执行体>>创建线程对象，调用start()方法启动线程

//创建线程方式之一：继承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方法开启线程
        testThread1.start();

        for (int i = 0; i < 20; i++) {
            System.out.println("我在学习多线程————"+i);
        }
    }
}

3.继承Thread类和实现Runnable接口对比

创建线程方式一：继承Thread类，重写run()方法，调用start线程
创建线程方式二：实现runnable，重写run方法，执行线程需要丢入runnable接口实现类，调用start方法
继承Thread类和实现Runnable接口对比，这里需要引入commons-io工具包实现网络下载

//创建线程方式之一：继承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方法开启线程
        testThread1.start();

        for (int i = 0; i < 20; i++) {
            System.out.println("我在学习多线程————"+i);
        }
    }
}

//练习实现多线程同步下载图片
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://i0.hdslb.com/bfs/article/735f7de46e0e891293c99323c5c4620c3ef117ae.jpg@1320w_2346h.webp","碧蓝航线1.jpg");
        TestThread2 t2 = new TestThread2("https://i0.hdslb.com/bfs/article/0cfe3289fb1ea4610477e81c03e788b403afeca1.jpg@1320w_1868h.webp","碧蓝航线2.jpg");
        TestThread2 t3 = new TestThread2("https://i0.hdslb.com/bfs/article/f94e072c0fd439ed340817813cd72fd8c5a2d804.png@1320w_2640h.webp","碧蓝航线3.jpg");

        t1.start();
        t2.start();
        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方法出现方法");
        }
    }
}

//创建线程方式2：实现runnable，重写run方法，执行线程需要丢入runnable接口实现类，调用start方法
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) {
        //创建runnable接口的实现类对象
        TestThread3 testThread3 = new TestThread3();
        //创建一个线程对象
//        Thread thread = new Thread(testThread3);
//
//        thread.start();
        new Thread(testThread3).start();

        for (int i = 0; i < 20; i++) {
            System.out.println("我在学习多线程————"+i);
        }
    }
}
//练习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://i0.hdslb.com/bfs/article/735f7de46e0e891293c99323c5c4620c3ef117ae.jpg@1320w_2346h.webp","碧蓝航线1.jpg");
        TestThread2 t2 = new TestThread2("https://i0.hdslb.com/bfs/article/0cfe3289fb1ea4610477e81c03e788b403afeca1.jpg@1320w_1868h.webp","碧蓝航线2.jpg");
        TestThread2 t3 = new TestThread2("https://i0.hdslb.com/bfs/article/f94e072c0fd439ed340817813cd72fd8c5a2d804.png@1320w_2640h.webp","碧蓝航线3.jpg");

        new Thread(t1).start();
        new Thread(t2).start();
        new Thread(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方法出现方法");
        }
    }
}

4.初识并发现问题

通过例子发现：多个线程操作同一个资源的情况下，线程不安全，数据紊乱

//多个线程同时操作同一个对象
//买火车票的例子

//通过例子发现：多个线程操作同一个资源的情况下，线程不安全，数据紊乱
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();
    }
}

在这里插入图片描述

5.龟兔赛跑模拟

1.Runnable，使用run()

2.首先要有赛道距离

3.判断比赛胜利

4.判断比赛是否结束

5.龟兔赛跑开始

6.故事中兔子是睡觉的，模拟兔子睡觉

//模拟龟兔赛跑
public class Race implements Runnable{

    private static String winner;
    @Override
    public void run() {
        //首先要有比赛距离
        for (int i = 0; i < 101; 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) {
        Race race = new Race();

        new Thread(race,"兔子").start();
        new Thread(race,"乌龟").start();
    }
}

6.Callable接口

创建线程方式三：实现Callable接口，重写call方法
创建执行服务： ExecutorService ser = Executors.newFixedThreadPool(1);
提交执行：Future r1 = ser.submit(t1);
获取结果：boolean rs1 = r1.get();
关闭服务：ser.shutdownNow();

//创建线程方式三：实现callable接口
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) throws ExecutionException, InterruptedException {
        TestCallable t1 = new TestCallable("https://i0.hdslb.com/bfs/article/735f7de46e0e891293c99323c5c4620c3ef117ae.jpg@1320w_2346h.webp","碧蓝航线1.jpg");
        TestCallable t2 = new TestCallable("https://i0.hdslb.com/bfs/article/0cfe3289fb1ea4610477e81c03e788b403afeca1.jpg@1320w_1868h.webp","碧蓝航线2.jpg");
        TestCallable t3 = new TestCallable("https://i0.hdslb.com/bfs/article/f94e072c0fd439ed340817813cd72fd8c5a2d804.png@1320w_2640h.webp","碧蓝航线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);

        //获取结果
        boolean rs1 = r1.get();
        boolean rs2 = r2.get();
        boolean rs3 = r3.get();
        
        //关闭服务
        ser.shutdownNow();
    }
}

//下载器
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方法出现方法");
        }
    }
}

7.静态代理模式

代理模式：为其他对象提供一种代理以控制对这个对象的访问。说白了就是"真实对象"的代表，在访问对象时引入一定程度的间接性，因为这种间接性可以附加多种用途。
好处：
代理对象可以做很多真实对象做不了的事情
真实对象专注做自己的事情
首先，要定义一个接口；其次，定义一个用户类来实现接口；再其次，定义代理类

/*
静态代理模式总结；
    真实对象和代理对象都要实现同一接口
    代理对象要代理真实角色
好处：
    代理对象可以做很多真实对象做不了的事情
    真实对象专注做自己的事情
 */
public class StaticProxy {
    public static void main(String[] args) {

        new Thread( ()-> System.out.println("愛してる") ).start();
        You you = new You();//你要结婚

        WeddingCompany weddingCompany = new WeddingCompany(new You());
        weddingCompany.HappyMarry();
    }
}

//1.首先要定义一个接口
interface Marry{

    void HappyMarry();
}

//2.定义一个用户类去实现这个接口
//真实角色，你去结婚
class You implements Marry{
    @Override
    public void HappyMarry() {
        System.out.println("僕と、結婚しましょう");
    }
}

//3.定义代理类
//婚姻公司，代理帮助结婚
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("结婚前，布置现场");
    }
}

8.Lambda表达式

为什么要使用Lambda：避免匿名内部类定义过多；可以让代码看起来简洁；去掉了一堆没有意义的代码，只留下核心逻辑
Functional Interface函数式接口：任何接口，有且仅有一个抽象方法，但可以有多个非抽象方法的接口

public interface Runnable{       //接口
    public abstract void run(); //抽象方法
}

逐步简化

①实现类

public class TestLambda3 {
    public static void main(String[] args) {
        King king = new General();
        king.queen(1);
    }
}

//首先定义一个接口
interface King{
    void queen(int a);
}

//1.  实现类
class General implements King{

    @Override
    public void queen(int a) {
        System.out.println("Obey  " + a);
    }
}

②静态内部类

public class TestLambda3 {
    
    //2.  静态内部类
    static class General2 implements King{
        @Override
        public void queen(int a) {
            System.out.println("Obey  " + a);
        }
    }
    
    public static void main(String[] args) {
        King king = new General2();
        king.queen(2);
    }
}
interface King{
    void queen(int a);
}

③局部内部类

public class TestLambda3 {
    public static void main(String[] args) {
    
        //3. 局部内部类
        class General3 implements King{
            @Override
            public void queen(int a) {
                System.out.println("Obey  " + a);
            }
        }
        
        King king = new General3();
        king.queen(3);
    }
}

interface King{
    void queen(int a);
}

④匿名内部类

public class TestLambda3 {
    public static void main(String[] args) {
        
        //4. 匿名内部类
        King king = new King() {
            @Override
            public void queen(int a) {
                System.out.println("Obey  " + a);
            }
        }; //
        
        king.queen(4);
    }
}

interface King{
    void queen(int a);
}

⑤lambda表达式

public class TestLambda3 {
    public static void main(String[] args) {
        //5. lambda表达式
        King king = (int a) -> {
                System.out.println("Obey  " + a);
        };
        king.queen(5);
    }
}
interface King{
    void queen(int a);
}

⑥再简化

public class TestLambda3 {
    public static void main(String[] args) {
        //5. lambda表达式
        King king = (int a) -> {
                System.out.println("Obey  " + a);
        };

        //简化1：去掉参数类型
        king = (a) -> {
            System.out.println("Obey  " + a);
        };
        
        //简化2：简化括号
        king = a -> {
            System.out.println("Obey  " + a);
        };
        
        //简化3：去掉花括号
        king = a -> System.out.println("Obey  " + a);
        
        king.queen(5);
    }
}
interface King{
    void queen(int a);
}

⑥再简化总结：

1.lambda表达式只能有一行代码的情况下，才能成为一行；如果有多行，那么使用代码块（即有花括号的）

2.简化前提是接口为函数式接口

3.多个参数也可以去掉参数类型，要去掉就都去掉，但必须要加上括号

griefseed

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java多线程学习——01

Java多线程学习——011.核心概念程序：是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念进程Process：是执行程序的一次执行过程，它是一个动态的概念，是系统资源分配的单位、通常在一个进程中可以包含若干个线程Thread，当然一个进程中至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的单位线程就是独立的执行路径。在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程、gc线程；main()称之为主线程，为系统的入口，用于执行整个程序
复制链接

扫一扫

专栏目录