多线程01

于 2024-11-21 01:16:32 发布
阅读量263 收藏 1
点赞数 4
CC 4.0 BY-SA版权
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/clever_quanquan/article/details/143925550

线程式独立执行的路径

在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程、gc线程等

main()称之为主线程，为系统的入口，用于执行整个程序

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

对同一份资源操作时，会存在资源抢夺的问题需要加入并发控制

线程会带来额外的开销，如CPU调度时间，并发控制开销

每个线程在自己的工作内存交互，内存控制不当会造成数据不一致

线程创建

三种创建方式：

Thread class：继承Thread类

Runnable接口：实现Runnable接口

Callable接口：实现Callable接口

Thread

自定义线程类继承Thread类

重写run()方法，编写线程执行体

创建线程对象，调用start()方法启动线程

package lesson1;

//创建线程方法一
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线程，主线程

        //创建一个线程对象，调用start()方法开启线程
        TestThread1 testThread1 = new TestThread1();
        testThread1.start();

        for (int i = 0; i < 20; i++) {
            System.out.println("我在吃饭---"+i);
        }
        //两条线程交替执行

    }
}

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

案例：下载图片

package lesson1;

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() {
        WebDownload webDownload = new WebDownload();
        try {
            webDownload.downloader(url,name);
            System.out.println("下载了文件名为："+name);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    public static void main(String[] args) {
        TestThread2 t1 = new TestThread2("https://x0.ifengimg.com/res/2024/B48B0C32B558F8A9D37FB374447154D854377E5D_size68_w700_h525.jpg","1.jpg");
        TestThread2 t2 = new TestThread2("https://imgoss.ilive.cn/image/202411/20/1732112595621_365x204.jpg","2.jpg");
        TestThread2 t3 = new TestThread2("https://imgoss.ilive.cn/image/202411/20/1732112596387_365x204.jpg","3.jpg");
        t1.start();
        t2.start();
        t3.start();
        //先下载t1,t2,t3，但是实际执行不是按照定义的顺序
    }
}

class WebDownload{
    //下载方法
    public void downloader(String url,String name) throws IOException {
        FileUtils.copyURLToFile(new URL(url),new File(name));

    }
}

实现Runnable

package lesson1;

//创建线程方法二：实现Runnable接口
public class TestThread3 implements Runnable{

    @Override
    public void 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);
        }
    }
}
package lesson1;

import java.io.IOException;

public class TestThread4 implements Runnable{

    private String url;//网络图片地址
    private String name;//保存的文件名

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

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

    public static void main(String[] args) {
        TestThread4 t1 = new TestThread4("https://x0.ifengimg.com/res/2024/B48B0C32B558F8A9D37FB374447154D854377E5D_size68_w700_h525.jpg","1.jpg");
        TestThread4 t2 = new TestThread4("https://imgoss.ilive.cn/image/202411/20/1732112595621_365x204.jpg","2.jpg");
        TestThread4 t3 = new TestThread4("https://imgoss.ilive.cn/image/202411/20/1732112596387_365x204.jpg","3.jpg");
        new Thread(t1).start();
        new Thread(t2).start();
        new Thread(t3).start();
        //先下载t1,t2,t3，但是实际执行不是按照定义的顺序
    }
}

对比：

继承Thread类：

        子类继承Thread类具备多线程能力

        启动线程：子类对象.start()

        不建议使用：避免OOP单继承局限性

实现Runnable接口：

        实现接口Runnable具有多线程能力

        启动线程：传入目标对象+Thread()对象.start()

        推荐使用：避免单继承的局限性，灵活方便，方便同一个对象被多个线程使用

package lesson1;

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


//发现问题：多个线程操作同一个资源的情况下，线程不安全，数据紊乱
public class TestThread5 implements Runnable{

    //票数
    private int ticketNums=10;

    @Override
    public void run() {
        while(true){
            if(ticketNums<=0){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"拿到了第"+ticketNums--+"张票");//获得名字
        }
    }

    public static void main(String[] args) {
        TestThread5 testThread5 = new TestThread5();
        new Thread(testThread5,"小明").start();
        new Thread(testThread5,"小郑").start();
        new Thread(testThread5,"小张").start();
    }
}

案例：龟兔赛跑

package lesson1;

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

    private static String winner;

    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {

            //模拟兔子休息
            if(Thread.currentThread().getName()=="兔子"&&i%10==0&&i!=0){
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }

            //判断比赛是否结束
            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();

    }
}

实现Callable接口

package lesson1;

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 {

    private String url;//网络图片地址
    private String name;//保存的文件名

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

    @Override
    public Boolean call() {
        WebDownload2 webDownload = new WebDownload2();
        try {
            webDownload.downloader(url,name);
            System.out.println("下载了文件名为："+name);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        TestCallable t1 = new TestCallable("https://x0.ifengimg.com/res/2024/B48B0C32B558F8A9D37FB374447154D854377E5D_size68_w700_h525.jpg","1.jpg");
        TestCallable t2 = new TestCallable("https://imgoss.ilive.cn/image/202411/20/1732112595621_365x204.jpg","2.jpg");
        TestCallable t3 = new TestCallable("https://imgoss.ilive.cn/image/202411/20/1732112596387_365x204.jpg","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();

        System.out.println(rs1);
        System.out.println(rs2);
        System.out.println(rs3);

        //关闭服务
        ser.shutdown();
        
    }
    
}

class WebDownload2{
    //下载方法
    public void downloader(String url,String name) throws IOException {
        FileUtils.copyURLToFile(new URL(url),new File(name));
    }
}

静态代理

package lesson1;

public class StaticProxy {
    public static void main(String[] args) {
        WeddingCompany weddingCompany = new WeddingCompany(new You());
        weddingCompany.HappyMarry();

    }
}

interface Marry{
    void HappyMarry();
}

//真实
class You implements Marry{

    @Override
    public void HappyMarry() {
        System.out.println("hhhh");
    }
}

//代理
class WeddingCompany implements Marry{

    private Marry target;

    public WeddingCompany(Marry target){
        this.target=target;
    }

    @Override
    public void HappyMarry() {
        before();
        this.target.HappyMarry();
        aftter();
    }

    private void before(){
        System.out.println("前");
    }

    private void aftter(){
        System.out.println("后");
    }

}

//静态代理模式：
//真实对象和代理对象要实现同一个接口
//代理对象代理真实对象
//代理对象可以做很多真实对象做不了的事情
//真实对象专注做自己的事情

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值