Java-多线程-狂神笔记

最新推荐文章于 2024-05-25 12:01:51 发布

VIP文章东萌潭海，西晓轮月

最新推荐文章于 2024-05-25 12:01:51 发布

阅读量141

点赞数

分类专栏： Java学习笔记狂神文章标签： java 多线程

本文链接：https://blog.csdn.net/weixin_42605958/article/details/118519536

版权

线程简介

process与Thread

一个软件（exe)是一个进程，软件中的声音图像是多线程
程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。
进程是执行程序的一次执行过程，是一个动态的概念。是系统分配资源的基本单位
真正执行的是线程，线程是CPU调度和执行的单位
注意：很多多线程是模拟出来的，真正的多线程是指有多个CPU，即多核，如服务器。如果是模拟出来的多线程，即在一个cpu下，在同一时间点，cpu只能执行一个代码，因为切换的很快，所以就有同时执行的错局。

本章核心概念

线程就是独立的执行路径
在程序执行时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程；
main()称之为主线程，为系统的入口，用于执行整个程序
在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为干预的
对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制
线程会带来额外的开销，如cpu调度时间，并发控制开销
每个线程在自己的工作内存交互，内存控制不当会造成数据不一致

线程实现（重点）

线程创建–Thread、Runnable、Callable

Thread class——继承Thread类（重点）
Runnable接口——实现Runnable接口（重点）
Callable接口——实现Callable接口（了解）

普通方法调用和多线程
普通方法（调用run())：主线程遇到t.run()，主线程跳出去执行run()，执行完回到主线程原来的地方继续执行
多线程（调用start())：主线程遇到t.start()后分成两条线，主线程继续执行，子线程执行run()方法。多条执行路径，主线程和子线程并行交替执行

继承Thread类
- 自定义线程类继承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);
        }
    }
}

注意：URL是统一资源定位符，包含文件位置信息，因此除了协议+域名+端口号+接口路径，协议+ip+接口路径，对于本地的图片可以直接 file:/// D:/picture/123.jpg

package com.pilgrims.demo1;

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("http://blog.kuangstudy.com/usr/themes/handsome/usr/img/sj/1.jpg","1.jpg");
        TestThread2 t2 = new TestThread2("http://blog.kuangstudy.com/usr/themes/handsome/usr/img/sj/2.jpg","2.jpg");
        TestThread2 t3 = new TestThread2("http://blog.kuangstudy.com/usr/themes/handsome/usr/img/sj/3.jpg","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异常，downloder方法出现问题");
        }
    }
}

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

package com.pilgrims.demo1;

//创建线程方式2：实现runnable接口，重写run方法，执行线程需要丢入runnable接口实现类
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类
- 子类继承Thread类具备多线程能力
- 启动线程：子类对象.start()
- 不建议使用：避免OOP单继承局限性
实现Runnable接口
- 实现接口Runnable具有多线程能力
- 启动线程：传入目标对象+Thread对象.start()
- 推荐使用：避免单继承局限性，灵活方便，方便同一对象被多个线程使用
- 解释：一份资源（传入一个目标对象）+多个代理（new 多个Thread，用的同一个目标对象）

//例如：
//一份资源
StartThread station = new StartThread();
//多个代理
new Thread(station, name:"小明“);
new Thread(station, name:"小红“);
new Thread(station, name:"老师“);

可以上面这么操作，但是多个线程操作统一资源，数据会紊乱

package com.pilgrims.demo1;

//多个线程同时操作同一个对象
//买火车票
//发现问题：多个线程操作同一个资源的情况下，线程不安全，数据紊乱
public class TestThread5 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) {
   
        TestThread5 ticket = new TestThread5();

        new Thread(ticket, "刘备").start();
        new Thread(ticket, "关羽").start();
        new Thread(ticket, "黄牛").start();
    }
}

//结果
关羽-->拿到了第10票
刘备-->拿到了第9票
黄牛-->拿到了第8票
刘备-->拿到了第7票
黄牛-->拿到了第6票
关羽-->拿到了第7票
关羽-->拿到了第5票
黄牛-->拿到了第4票
刘备-->拿到了第5票
刘备-->拿到了第3票
黄牛-->拿到了第3票
关羽-->拿到了第3票
关羽-->拿到了第2票
黄牛-->拿到了第2票
刘备-->拿到了第1票

说明

以上情形用静态代理上说属于一份资源（传入一个目标对象）+多个代理（new 多个Thread，用的同一个目标对象），而我们知道，多个代理对应的都是该类继承的Thread类，这样的话就产生了多继承的情形，即一个TestThread子类的对象有三个代理，也就是继承了三个类（尽管是相同的父类，但是程序依然无法确定要去执行哪个类中的方法，还是会冲突）
因为java是不支持多继承的，就是说如果你继承了别的类，就别想实现多线程，如果你想实现多线程，就别想同时继承别的类，这就有了对类的拓展有了非常大的局限性
Thread是类，是多个线程分别完成自己的任务（一对一），每个线程都有一个相关联的唯一对象；Runnable是接口，是多个线程共同完成一个任务（多对一），多线程可以共享同一个Runnable实例。
继承Thread实现方式实际上是重写了 run() 方法，由于线程的资源和 Thread 实例捆绑在一起，所以不同的线程的资源不会进行共享。
实现Runnable接口实现方式就是静态代理的方式，线程资源与 Runable 实例捆绑在一起，Thread 只是作为一个代理类，所以资源可以进行共享。
实现Runnable使你的类更灵活。如果您继承Thread类，那么您所做的操作总是处于一个线程中。然而如果你采用实现Runnable接口，您可以在一个线程中运行它，或者将它传递给某种执行器（executor），或者只是将它作为一个单线程应用程序中的任务传递给它。

为什么java不可以多继承却可以多接口

为什么不能实现类的多继承？主要是防止多个类有相同的方法名，然而方法体不一样，子类就比较难选择了。所以java和C#不支持类的多继承
允许具有多个接口的一个好处就是，当实现多个接口时，如果两个接口有同样的方法，那么实现一次就可以了。由于接口没有方法体，所以接口可以实现多继承。

龟兔赛跑

package com.pilgrims.demo1;

//模拟龟兔赛跑
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%20 == 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 racer = new Race();

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

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

package com.pilgrims.demo2;

import com.pilgrims.demo1.TestThread2;
import org.apache.commons.io.FileUtils;

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

//线程创建方式3：实现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) throws ExecutionException, InterruptedException {
   
        TestCallable t1 = new TestCallable("file:///D:/每日一题/a.jpg","1.jpg");
        TestCallable t2 = new TestCallable("file:///D:/每日一题/b.jpg"

最低0.47元/天解锁文章

东萌潭海，西晓轮月

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java-多线程-狂神笔记

线程简介process与Thread一个软件（exe)是一个进程，软件中的声音图像是多线程程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。进程是执行程序的一次执行过程，是一个动态的概念。是系统分配资源的基本单位真正执行的是线程，线程是CPU调度和执行的单位注意：很多多线程是模拟出来的，真正的多线程是指有多个CPU，即多核，如服务器。如果是模拟出来的多线程，即在一个cpu下，在同一时间点，cpu只能执行一个代码，因为切换的很快，所以就有同时执行的错局。本章核心
复制链接

扫一扫