【多线程】02

原创 于 2018-11-25 23:23:01 发布 · 139 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#Java多线程

本文详细介绍了在Java中实现多线程的三种主要方法：继承Thread类、实现Runnable接口和使用Callable接口。通过示例代码，展示了每种方法的特点和应用场景，包括线程的启动、执行和资源管理。

Java中如何实现多线程？

第一种方法：继承Thread，通过创建Thread的实例来创建新的线程，开辟一条新的程序执行路径

/**
 * 
 */
package com.vista.thread;

/**
 * 模拟龟兔赛跑
 1.继承Thread 实例化Thread 创建多线程 + 重写run方法（线程体）
 2.使用线程 创建子类对象 + 对象.start() 线程启动（不等于线程执行，只是进度就绪状态，要看CPU调度）
 *
 */
public class TortoiseAndRabbit {

}

class Tortoise extends Thread {
    @Override
    public void run() {
        //线程体
        for (int i = 0; i < 100; i++) {
            System.out.println("乌龟跑了" + i + "步");
        }
    }
}

class Rabbit extends Thread {
    @Override
    public void run() {
        //线程体
        for (int i = 0; i < 100; i++) {
            System.out.println("兔子跑了" + i + "步");
        }
    }
}

 

/**
 * 
 */
package com.vista.thread;

/**
 * @author Vistas
 *
 */
public class TortoiseAndRabbitApp {

    /**   
     * @Description: TODO
     * @author: Vistas   
     * @date: 2018-11-25 上午11:37:38 
     */
    public static void main(String[] args) {
        //创建Thread子类对象
        Rabbit rab = new Rabbit();
        Tortoise tor = new Tortoise();

        //调用start方法 启动线程 等待cpu调用
        rab.start();//开辟新的执行路径，不要调用对象的run方法
        tor.start();

        for (int i = 0; i < 100; i++) {
            System.out.println("main方法==" + i);
        }
    }

}

 

/**
 * 
 */
package com.vista.thread;

/**
 * @author Vistas
 *
 */
public class TortoiseAndRabbitApp {

    /**   
     * @Description: TODO
     * @author: Vistas   
     * @date: 2018-11-25 上午11:37:38 
     */
    public static void main(String[] args) {
        //创建Thread子类对象
        Rabbit rab = new Rabbit();
        Tortoise tor = new Tortoise();

        //调用start方法 启动线程
        rab.run();//调用对象的run方法，则为普通的方法调用，程序并没有开辟新的执行路径，程序依然顺序执行
        tor.run();

        for (int i = 0; i < 100; i++) {
            System.out.println("main方法==" + i);
        }
    }

}

 

Thread中实现了Runnable接口，重写了run()方法，我们上述实现方法传入的target为空，所以需要我们自己去实现run方法

    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }

类实例化Thread来实现多线程的缺点：如果一个类已经继承了一个类，就无法通过继承Thread来实现多线程了

第二种方法：通过Runnable接口实现多线程

优点：可以同时实现继承，避免了单继承，方便资源共享，同一份资源，多个代理访问

Runnable接口的实现用到了代理模式，如下介绍一下静态代理模式

 

 

/**
 * 
 */
package com.vista.thread;

/**
 * 静态代理 设计模式
 * 1.真是角色
 * 2.代理角色 + 持有真实角色的引用
 * 3.二者实现相同的接口
 *
 */
public class StaticProxy {

    public static void main(String[] args) {
        //创建真实角色
        You you = new You();
        //创建代理角色 + 加入真实角色的引用
        MarryCompany marryCompany = new MarryCompany(you);
        marryCompany.marry();
    }

}

//接口
interface Marry {
    void marry();
}

//真实角色
class You implements Marry {

    @Override
    public void marry() {
        System.out.println("你和爱人结婚了...");
    }

}

//代理角色
class MarryCompany implements Marry {
    //真实角色的引用
    private Marry you;

    public MarryCompany() {
    }

    public MarryCompany(Marry you) {
        this.you = you;
    }

    private void before() {
        System.out.println("筹备婚礼...");
    }

    private void after() {
        System.out.println("结婚后过幸福生活...");
    }

    @Override
    public void marry() {
        before();
        you.marry();
        after();
    }
}

我们知道，Thread实现了Runnable接口，可以充当代理角色，我们只要写一个类同样实现Runnable接口，并重写run方法。

/**
 * 
 */
package com.vista.thread;

/**
 *使用 Runnable 创建线程
 *1.类 实现Runnable接口 + 重写run()方法 -->真实角色类
 *2.启动多线程 使用静态代理
 *  1).创建真实角色
 *  2).创建代理角色 + 真实角色的引用
 *  3).调用 .start()方法，启动线程
 */
public class Programmer implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("一边敲代码...");
        }
    }
}

 

/**
 * 
 */
package com.vista.thread;

/**
 * 推荐 Runnable 创建多线程
 *   1).避免单继承的局限性
 *   2).便于共享资源
 *
 */
public class ProgrammerApp {

    public static void main(String[] args) {
        //1).创建真实角色
        Programmer programmer = new Programmer();
        //2).创建代理角色 + 真实角色的引用
        Thread proxy = new Thread(programmer);
        //3).调用 .start()方法，启动线程
        proxy.start();

        for (int i = 0; i < 100; i++) {
            System.out.println("一边聊天...");
        }
    }

}

 

/**
 * 
 */
package com.vista.thread;

/**
 * @author Vistas
 *
 */
public class Web12306 implements Runnable {
    private int num = 50;

    @Override
    public void run() {
        while (true) {
            if (num <= 0) {
                break;//跳出循环
            }
            System.out.println(Thread.currentThread().getName() + num--);
        }
    }

    public static void main(String[] args) {
        //真实角色
        Web12306 web = new Web12306();
        //代理角色
        Thread t1 = new Thread(web, "路人甲");
        Thread t2 = new Thread(web, "黄牛乙");
        Thread t3 = new Thread(web, "路人丙");
        //启动线程
        t1.start();
        t2.start();
        t3.start();
    }
}

实现Runnable接口创建线程，不能获取返回值，不能抛出除运行时异常以外的异常

第三种方法：通过Callable接口实现多线程

优点：可以获取返回值

Callable和Future接口

Callable接口类似于Runnable接口，实现这两者的类都是可被其他线程执行的任务

Callable和Runnable有以下不同：

（1）.Callable规定的方法是call()，而Runnable规定的方法是run();

（2）.call()方法可抛出异常，而run()方法不能抛出异常

（3）.Callable的任务执行后可返回值，运行Callable任务可拿到一个Future对象，而Runnable的任务是不能返回值的。Future表示异步计算的结果，它提供了检查任务是否完成的方法，以等待计算的完成，并累计计算的结果。通过Future对象可了解任务执行的情况，可取消任务的执行，还可获得任务执行的结果。

缺点：实现较为繁琐

思路：

1）. 创建Callable实现类 + 重写call() 

2）.借助 执行调度服务 ExecutorService ，获取Future对象 

 ExecutorService service = Executors.newFixedThreadPool(2);

 Future result = service.submit(传入实现类对象);

3）.获取值result.get()

4）.停止服务service.shutdownNow();

/**
 * 
 */
package com.vista.thread;

import java.io.IOException;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * @author Vistas
 *
 */
public class Call {
    public static void main(String[] args) throws IOException, InterruptedException, ExecutionException {
        //创建线程
        ExecutorService service = Executors.newFixedThreadPool(2);
        Race tortoise = new Race("乌龟", 1000);
        Race rabbit = new Race("兔子", 500);
        //获取值
        Future<Integer> result1 = service.submit(tortoise);
        Future<Integer> result2 = service.submit(rabbit);

        Thread.sleep(2000);//2秒
        tortoise.setFlag(false);//停止线程体循环
        rabbit.setFlag(false);

        int num1 = result1.get();
        int num2 = result2.get();
        System.out.println("乌龟跑了 " + num1 + " 步");
        System.out.println("兔子跑了 " + num2 + " 步");
        //停止服务
        service.shutdownNow();
    }
}

class Race implements Callable<Integer> {
    private String name;
    private long time;
    private boolean flag = true;
    private int step = 0;

    public Race() {
    }

    public Race(String name, long time) {
        this.name = name;
        this.time = time;
    }

    @Override
    public Integer call() throws Exception {
        while (flag) {
            Thread.sleep(time);//延时
            step++;
        }
        return step;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public long getTime() {
        return time;
    }

    public void setTime(long time) {
        this.time = time;
    }

    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }

    public int getStep() {
        return step;
    }

    public void setStep(int step) {
        this.step = step;
    }

}

 

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值