Java多线程--狂神说

最新推荐文章于 2023-07-19 20:23:29 发布

卿陈

最新推荐文章于 2023-07-19 20:23:29 发布

阅读量286

点赞数 1

本文链接：https://blog.csdn.net/qq_43203246/article/details/109608530

版权

多线程

简介

任务线程Thread 进程 Process多线程

多任务看似同时进行多项任务实际同一时间只能做一次

进程：执行程序的一次执行过程，动态概念包含若干个线程至少一个

多线程是模拟出来的切换速度快而已

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

创建进程

继承Thread类（重点）
使用runnable接口（重点）
了解callable接口

继承Thread类

在这里插入图片描述

package thread;

//创建线程方式一: 继承Thread类,重写run()方法，start开启多线程
public class ThreadCreate extends Thread {
   
    @Override
    public void run() {
   
        for (int i = 0; i < 20; i++) {
   
            System.out.println(i+"我在看代码");

        }
    }

    public static void main(String[] args) {
   
        //main线程 主线程
        //创建一个线程对象
        ThreadCreate threadCreate = new ThreadCreate();
        //调用start（）线程
        threadCreate.start();
        //threadCreate.run();普通方法 先调用"我在看代码"后"我在跑程序"

        for (int i = 0; i < 2000; i++) {
   
            System.out.println(i+"我在跑程序");

        }


    }
}

总结：注意，线程开启不一定立即执行，由cpu调度执行

网图下载

package thread;

import org.apache.commons.io.FileUtils;

import javax.swing.*;
import java.io.File;
import java.io.IOException;
import java.net.URL;

public class ThreadCreate2 extends  Thread{
   

    private  String url;
    private  String name;

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

    @Override
    public void run() {
   
        WebDownLoader webDownLoader = new WebDownLoader();
        webDownLoader.DownLoader(url,name);
        System.out.println("下载了文件为:"+name);
    }

    public static void main(String[] args) {
   
        ThreadCreate2 t1 = new ThreadCreate2("1.jpg","https://dss3.bdstatic.com/70cFv8Sh_Q1YnxGkpoWK1HF6hhy/it/u=2534506313,1688529724&fm=26&gp=0.jpg");
        ThreadCreate2 t2 = new ThreadCreate2("2.jpg","https://dss3.bdstatic.com/70cFv8Sh_Q1YnxGkpoWK1HF6hhy/it/u=2534506313,1688529724&fm=26&gp=0.jpg");
        ThreadCreate2 t3 = new ThreadCreate2("3.jpg","https://dss3.bdstatic.com/70cFv8Sh_Q1YnxGkpoWK1HF6hhy/it/u=2534506313,1688529724&fm=26&gp=0.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异常 download方法出现问题");
        }
    }
}
下载了文件为:3.jpg
下载了文件为:1.jpg
下载了文件为:2.jpg

实现runnable接口

package thread;

//创建线程2:实现runnable接口，重写run()方法 执行线程需要将runnable丢入
public class TestCreate3 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(i+"我在看代码");
        }
    }

    public static void main(String[] args) {
        //创建runnable接口的实现类对象
        TestCreate3 testCreate3 = new TestCreate3();
        //创建线程对象，通过线程对象来开启我们的线程 代理
        new Thread(testCreate3).start();

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

    }
}
0我在执行多线程
0我在看代码
1我在执行多线程
1我在看代码
2我在看代码
3我在看代码

总结:

继承Thread类

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

实现runnable接口

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

package thread;

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

//发现问题：多个线程使用同一份资源 线程不安全 数据紊乱
public class TestThread2 implements Runnable{
   
    //车票数
    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) {
   
        TestThread2 ticket = new TestThread2();
        new Thread(ticket,"学生").start();
        new Thread(ticket,"打工者").start();
        new Thread(ticket,"黄牛党").start();

    }
}
学生-->拿到了第4张票
黄牛党-->拿到了第4张票
打工者-->拿到了第2张票
学生-->拿到了第2张票
黄牛党-->拿到了第1张票

龟兔赛跑

package thread;

import com.sun.deploy.nativesandbox.NativeSandboxBroker;

public class Race implements Runnable{
    private static String winner;//胜利者

    @Override
    public void run() {
        if(Thread.currentThread().getName().equals("兔子")){
        for (int i = 2; i <=100; i+=2) {
            boolean flag=gameover(i);
            if(flag){
                break;
            }
            System.out.println("兔子跑了"+i+"步");
            if(i%50==0){
                try {
                    Thread.sleep(2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        }else{
            for (int i = 1; i <= 100; i++) {
                boolean flag=gameover(i);
                if(flag){
                    break;
                }
                System.out.println(Thread.currentThread().getName()+"跑了"+i+"步");
            }
        }

    }

    public boolean gameover(int step){
        if(winner!=null){
            return true;
        }else if(step>=100){
            winner=Thread.currentThread().getName();
            System.out.println("winner is "+winner);
            return true;
        }else{
            return false;
        }
    }

    public static void main(String[] args) {
        Race race = new Race();

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

    }
}
winner is 乌龟
兔子跑了52步

龟兔都有希望获胜但有个问题在于即便胜利者出现有时还会有一个前进这是因为用了if 后相当与两个线程故有反应时间差吧

实现Callable

1.实现Callable,需要返回值类型

2.重写call方法，需要抛出异常

3.创建目标对象

4.创建执行服务：ExecutorService ser=Executors.newFixedThreadPool(1)

5.提交执行：Futureresult1=ser.submit(t1);

6.获取结果：Boolean r1 =result.get()

7.关闭服务:ser.shutdownNow();

package thread;

import org.apache.commons.io.FileUtils;

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

public class TestCallable implements Callable<Boolean>{
   

    private  String url;
    private  String name;

    public TestCallable(String name,String url) {
   
        this.name = name;
        this.url=url;
    }
    @Override
    public Boolean call() {
   
        WebDownLoader1 webDownLoader1 = new WebDownLoader1();
        webDownLoader1.DownLoader(url,name);
        System.out.println("下载了文件为:"+name);
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
   
        TestCallable t1 = new TestCallable("1.jpg","https://dss3.bdstatic.com/70cFv8Sh_Q1YnxGkpoWK1HF6hhy/it/u=2534506313,1688529724&fm=26&gp=0.jpg");
        TestCallable t2 = new TestCallable("2.jpg","https://dss3.bdstatic.com/70cFv8Sh_Q1YnxGkpoWK1HF6hhy/it/u=2534506313,1688529724&fm=26&gp=0.jpg");
        TestCallable t3 = new TestCallable("3.jpg","https://dss3.bdstatic.com/70cFv8Sh_Q1YnxGkpoWK1HF6hhy/it/u=2534506313,1688529724&fm=26&gp=0.jpg");

        //4.创建执行服务
        ExecutorService ser= Executors.newFixedThreadPool(3);

        //5.提交执行
        Future<Boolean> result1=ser.submit(t1);
        Future<Boolean> result2=ser.submit(t2);
        Future<Boolean> result3=ser.submit(t3);

        //6.获取结果
        Boolean r1 =result1.get();
        Boolean r2 =result1.get();
        Boolean r3 =result1.get();
        System.out.println(r1);
        System.out.println(r2);
        System.out.println(

最低0.47元/天解锁文章

卿陈

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
1
评论
Java多线程--狂神说

多线程简介任务线程Thread 进程 Process多线程多任务看似同时进行多项任务实际同一时间只能做一次进程：执行程序的一次执行过程，动态概念包含若干个线程至少一个多线程是模拟出来的切换速度快而已线程是独立的执行路径程序运行时，即使没有自己创建线程，后台也或有多个线程如主线程，gc线程进程中，如果包含多个线程，线程的运行由调度器安排调度，调度器与操作系统紧密相关，先后顺序不能人为干扰main（）称之为主进程，为系统的入口，用于执行整个程序对同一份资源操作时，会存在资
复制链接

扫一扫