多线程（1）——线程与进程、并发编程、Thread的底层实现—静态代理

最新推荐文章于 2022-12-01 09:07:27 发布

王Java·

最新推荐文章于 2022-12-01 09:07:27 发布

阅读量83

点赞数

文章标签： java 多线程 thread

本文链接：https://blog.csdn.net/weixin_42182892/article/details/106349765

版权

学习视频B站狂神java多线程：https://www.bilibili.com/video/BV1V4411p7EF?

线程（Thread）与进程（Process）

程序：指令和数据的有序集合，静态
进程：执行程序的一次执行过程，动态
线程：一个进程中包含若干个线程，一个进程中至少一个线程
真正的多线程通过多个cpu进行，模拟的多线程在一个cpu中不断切换线程

线程的创建

继承Thread类
1、自定义线程类继承Thread类
2、重写run()方法，编写线程执行体
3、创建线程对象，调用start()方法启动线程

class TestThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("看书" + i);
        }
    }


    public static void main(String[] args) {
        //调用线程
        TestThread tt = new TestThread();
        tt.start();
        //主函数方法
        for (int i = 0; i < 200; i++) {
            System.out.println("睡觉" + i);
        }

    }
}

4、线程的同步性
调用Thread的start()方法，开启新的线程，不同线程同步进行，线程通过cpu进行调度

    public static void main(String[] args) {
        //调用线程
        TestThread tt=new TestThread();
        tt.start();//调用Thread的start()方法，线程和主函数线程同步进行
        //主函数方法
        for(int i=0;i<200;i++){
            System.out.println("睡觉"+i);
        }
    }

在这里插入图片描述
调用Thread的run()方法，不能开启新的线程，按照代码先后顺序依次执行

    public static void main(String[] args) {
        //调用线程
        TestThread tt=new TestThread();
        tt.run();//调用TestThread类的run()方法
        //主函数方法
        for(int i=0;i<200;i++){
            System.out.println("睡觉"+i);
        }
    }

在这里插入图片描述

实现Runnable接口（推荐使用，因为单继承的局限性）
1、Thread也通过实现Runnable接口实现多线程
2、定义MyRunnable类实现Runnable接口
3、实现 run()方法，编写线程执行体
4、创建线程对象，调用start()方法启动线程

public class TestThread2 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("看书" + i);
        }
    }


    public static void main(String[] args) {
        //创建Runnable接口的实现类对象
        TestThread2 tt = new TestThread2();

        //创建线程对象，通过线程对象来开启线程，代理
        //方法1
//      Thread thread=new Thread(tt);
//      thread.start();
        //方法2
        new Thread(tt).start();
        
        //主函数方法
        for (int i = 0; i < 200; i++) {
            System.out.println("睡觉" + i);
        }

    }
}

在这里插入图片描述
Thread源码中传入Runnable接口对象创建进程对象：

public Thread(Runnable target) {
        this(null, target, "Thread-" + nextThreadNum(), 0);
    }

实现Callable接口
1、有返回值
2、可以抛出异常

public class TestCallable implements Callable<String> {
    private int tickets=10;

    @Override
    public String call() throws Exception {
        return Thread.currentThread().getName()+"-->拿到第"+tickets--+"张票";
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        TestCallable tc1=new TestCallable();
        //创建执行服务
        ExecutorService ser= Executors.newFixedThreadPool(3);
        //提交执行
        Future<String> r1=ser.submit(tc1);
        Future<String> r2=ser.submit(tc1);
        Future<String> r3=ser.submit(tc1);
        //获取结果
        System.out.println(r1.get());
        System.out.println(r2.get());
        System.out.println(r3.get());
        //关闭服务
        ser.shutdownNow();

    }
}

继承Thread和实现Runnable接口实现多线程的区别

继承Thread类实现多线程，每实例化一个该线程类对象，就创建了一条线程，并且每条线程之间是不相干的，每一条线程均独立完成run()方法中的任务，即 每个线程都有一个独立的run()任务
实现Runnable接口实现多线程，使用时实例化实现Runnable接口的类对象，将该类对象作为参数，分别传入多个Thread实现方法中，创建多个线程，但是因为使用的是同一个参数，因此多线程之间是相统一的，一起完成run()方法
继承Thread类案例

class TestThread {
    public static void main(String[] args) {
        ticket t1 = new ticket("窗口1");
        ticket t2 = new ticket("窗口2");
        t1.start();
        t2.start();
    }
}
class ticket extends Thread{
    public ticket(String name){
        super(name);
    }
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + "=="+i);
        }
    }
}

在这里插入图片描述
两个窗口各自完成各自的run()

实现Runnable接口实例

class TestThread {
    public static void main(String[] args) {
        ticket t = new ticket();//同一个类对象
        new Thread(t).start();
        new Thread(t).start();
    }
}

class ticket implements Runnable {
    int tickets = 5;

    @Override
    public void run() {
        while(true) {
            if (tickets <= 0) {
                break;
            }
            System.out.println(Thread.currentThread().getName() + "==" + tickets--);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

在这里插入图片描述
两个线程共同完成run()

并发编程

public class TestThread3 implements Runnable{

    private int ticket=10;

    @Override
    public void run() {
        while(ticket>0){
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"拿到第"+ticket--+"张票");
        }
    }

    public static void main(String[] args) {
        TestThread3 tt3=new TestThread3();
        //开启多个线程
        new Thread(tt3,"A").start();
        new Thread(tt3,"B").start();
        new Thread(tt3,"C").start();
    }
}

将每个线程执行一次run()方法中线程sleep200ms，发现不同线程会取到同一张票，甚至有时候会得到0或者-1的票：
在这里插入图片描述
这里就引出了多线程操作同一个资源的时候线程不安全的问题，线程的并发问题

龟兔赛跑模拟线程sleep

public class Race implements Runnable{
    private static String winner;
    @Override
    public void run() {
        for(int i=1;i<101;i++){
            if(Thread.currentThread().getName()=="兔子"){
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            boolean flag=gameOver(i);
            if(flag){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"-->跑了"+i+"步");
        }
    }
    //判断比赛是否结束
    public boolean gameOver(int steps){
        if(winner!=null){//第一个进程到达终点后，用于判断终止第二个进程
            return true;
        }
        if(steps>=100){//对第一个到达终点进行判定，将其name赋给winner
            winner=Thread.currentThread().getName();
            System.out.println("winner是-->"+winner);
            return true;
        }else{
            return false;
        }
    }

    public static void main(String[] args) {
        Race race=new Race();
        new Thread(race,"兔子").start();
        new Thread(race,"乌龟").start();
    }
}

在这里插入图片描述

Thread的底层实现——静态代理

public class TestStaticProxy {
    public static void main(String[] args) {
        new company(new person()).marry();
    }
}
//marry接口
interface Marry{
    void marry();
}
//婚礼主体，被company代理的人，作为参数传入company中
class person implements Marry{
    public void marry(){
        System.out.println("person结婚");
    }
}
//代理公司，main中调用company来完成company工作和对婚礼主体person的代理工作
class company implements Marry{
    private Marry target_person;
    
    company(Marry target_person){
        this.target_person=target_person;
    }
    @Override
    public void marry() {
        before();
        target_person.marry();
        after();
    }

    private void after() {
        System.out.println("company承办婚礼后");
    }

    private void before() {
        System.out.println("company承办婚礼前");
    }
}

在这里插入图片描述
对比Thread的实现过程和静态代理的方法，可以发现是相一致的：

//company和person均实现Marry接口，company代理person，将person作为参数传入company构造器，使得company能够完成person的工作
new company(new person()).marry();
//Thread和TH均实现Runnable接口，Thread代理TH，将TH作为参数传入Thread构造器，使得Thread能够完成TH的工作
new Thread(new TH()).start();

静态代理模式总结：
1、真实对象和代理对象均实现同一个接口
2、代理对象代理真实对象
3、优点：代理对象可以做很多真实对象做不了的事情、真实对象能够专注做自己的事情

王Java·

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
多线程（1）——线程与进程、并发编程、Thread的底层实现—静态代理

线程（Thread）与进程（Process）程序：指令和数据的有序集合，静态进程：执行程序的一次执行过程，动态线程：一个进程中包含若干个线程，一个进程中至少一个线程真正的多线程通过多个cpu进行，模拟的多线程在一个cpu中不断切换线程线程的创建继承Thread类1、自定义线程类继承Thread类2、重写run()方法，编写线程执行体3、创建线程对象，调用start()方法启动线程class TestThread extends Thread { @Override
复制链接

扫一扫