栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

Java-多线程

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

Java-多线程

大家都知道,像我们平常观看直播的弹幕是怎样实现的吗? 通过多线程实现的群发弹幕

什么是线程呢?

线程(thread)是一个程序内部的一条执行路径。程序中如果只有一条执行路径,那么这个程序就是单线程的程序。

就例如:我们之前启动程序执行后,main方法的执行其实就是一条单独的执行路径。

多线程什么呢?

多线程是指从软硬件上实现多条执行流程的技术。

多线程用在哪里,有什么好处?

消息通信、淘宝、京东系统都离不开多线程技术。

多线程是这么实现的呢?

我总结了三种Java实现多线程的方案:

一、多线程的实现方案一:继承Thread类

1、定义一个子类MyThread继承线程类java.lang.Thread,并重写run()方法

 class MyThread extends Thread{
    
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程执行了:"+i);
        }
    }
}

2、创建 MyThread类的对象

//3、new一个新线程对象
Thread t = new MyThread();

3、调用线程对象的start()方法启动线程(启动以后还是会执行run方法的)

//4、调用start方法启动线程(执行的还是run方法)
t.start();

4、完整代码

a.主类

//主类

public class ThreadDemo1 {
    public static void main(String[] args) {
        //3、new一个新线程对象
        Thread t = new MyThread();

        //4、调用start方法启动线程(执行的还是run方法)
        t.start();

        for (int i = 0; i < 5; i++) {
            System.out.println("主线程执行了:"+i);
        }
    }
}

b.子类 

//子类



 class MyThread extends Thread{
    
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程执行了:"+i);
        }
    }
}

优缺点:

优点:编码简单

缺点:线程已经继承了Thread,无法继承其他类了,不利于扩展。

注意:

为什么不直接调用了run方法,而是调用start启动线程。

直接调用run方法会当成普通方法执行,此时相当于还是单线程执行。 只有调用start方法才是启动一个新的线程执行。 

一定不要把主线程任务放在子线程之前了。

因为这样会使主线程一直是先跑完的,相当于是一个单线程的效果了。

二、多线程的实现方案二:实现Runnable接口

1、定义一个线程任务类MyRunnable实现Runnable接口,重写run()方法

class MyRunnable implements Runnable{
    
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("子线程执行了:"+i);
        }

    }
}

2、创建MyRunnable任务对象

//3、创建一个任务对象
Runnable target = new MyRunnable();

3、把MyRunnable任务对象交给Thread处理。

//4、把任务对象交给Thread处理
Thread t = new Thread(target);

 4、调用线程对象的start()方法启动线程

//5、启动线程
t.start();

5、完整代码

a.主类

//主类


public class ThreadDemo2 {
    public static void main(String[] args) {
        //3、创建一个任务对象
        Runnable target = new MyRunnable();
        //4、把任务对象交给Thread处理
        Thread t = new Thread(target);
        //5、启动线程
        t.start();


        for (int i = 0; i < 10; i++) {
            System.out.println("主线程执行了:"+i);
        }
    }
}

b.子类 

//子类


class MyRunnable implements Runnable{
    
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("子线程执行了:"+i);
        }

    }
}

另一种多线程的实现方案二:匿名内部类方式实现

1、可以创建Runnable的匿名内部类对象。

//1、创建一个任务对象
        Runnable target = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println("子线1程执行了:" + i);
                }
            }
        };

2、交给Thread处理。

//2、把任务对象交给Thread处理
Thread t = new Thread(target);

3、调用线程对象的start()启动线程。

//3、启动线程
t.start();

4、完整代码

 

public class ThreadDemo2Other {
    public static void main(String[] args) {
        //1、创建一个任务对象
        Runnable target = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println("子线1程执行了:" + i);
                }
            }
        };
        //2、把任务对象交给Thread处理
        Thread t = new Thread(target);
        //3、启动线程
        t.start();


        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println("子线2程执行了:" + i);
                }
            }
        }).start();

        new Thread(() -> {
                for (int i = 0; i < 10; i++) {
                    System.out.println("子线3程执行了:" + i);
                }
        }).start();




        for (int i = 0; i < 10; i++) {
            System.out.println("主线程执行了:"+i);
        }
    }
}

 优缺点:

优点:线程任务类只是实现接口,可以继续继承类和实现接口,扩展性强。

缺点:编程多一层对象包装,如果线程有执行结果是不可以直接返回的。

三、多线程的实现方案三:JDK 5.0新增:实现Callable接口

1、得到任务对象

a.定义类实现Callable接口,重写call方法,封装要做的事情。

class MyCallable implements Callable{
    private int n;

    public MyCallable(int n) {
        this.n = n;
    }

    
    @Override
    public String call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += i;
        }
        return "子线程的执行结果是:"+sum;
    }
}

b.用FutureTask把Callable对象封装成线程任务对象。

//3、创建Callable任务对象
        Callable call = new MyCallable(100);
        //4、把Callable任务对象 交给FutureTask 对象
        //FutureTask对象的作用1:是Runnable的对象(实现了Runnable接口),可以交给Thread了
        //FutureTask对象的作用2:可以在线程执行完毕之后通过调用其get方法得到线程执行完成的结果
        FutureTask f1 = new FutureTask<>(call);

2、把线程任务对象交给Thread处理。

//5、交给线程处理
Thread t1 = new Thread(f1);

3、调用Thread的start方法启动线程,执行任务

//6、启动线程
t1.start();

4、线程执行完毕后、通过FutureTask的get方法去获取任务执行的结果。

//7、线程执行完毕后、通过FutureTask的get方法去获取任务执行的结果。
        try {
            String s1 = f1.get();
            System.out.println("第一个结果"+s1);
        } catch (Exception e) {
            e.printStackTrace();
        }

5、这样你看到的其实是一个单线程的任务,如果要实现多线程你可以在创建一个Callable任务对象。如上,继续往下执行就可以了。这里我实现了一个求和的函数,比较简单。如果有要实现难的 函数照样,重写call方法在里面写上你所要执行的函数就OK了。

优缺点:

优点:线程任务类只是实现接口,可以继续继承类和实现接口,扩展性强。

可以在线程执行完毕后去获取线程执行的结果。

缺点:编码复杂一点。

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/948830.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号