陶永攀

浏览: 100440 次
性别:
来自: 郑州

最近访客更多访客>>

delin_OneZero

youcp999

waxuan_00

ft3159572

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

线程的三种重建

博客分类：

Java

Java

一、创建线程的方法有三种：

（1）继承Thread类,重写run方法；

（2）实现Runnable接口，并将对象实例作为参数传递给Thread类的构造方法；

（3）实现callable接口，并实现call方法，并且线程执行完毕后会有返回值。

注意：（1）和（2）都是调用start()方法启动线程的，然后JVM虚拟机将此线程放到就绪队列中，有处理

机可用时，则执行run方法。这两种方法都重写了run方法，但是没有返回值。

（1）继承Thread类,重写run方法；

启动：创建子类对象+对象.start()
缺点：Java只支持单继承，如果我们的类已经从一个类继承，则无法再继承Thread类

package xiancheng_creat;

/**
 * Created by Taoyongpan on 2017/5/6.
 *
 * 模拟龟兔赛跑
 * 1、创建多线程（方式一）：继承 Thread + 重写run方法（线程体）
 * 2、使用线程：创建子类对象  + 对象.start()方法  线程启动
 */
public class MyThread {
    public static void main(String[] args) {
        //创建子类对象
        Rabbit rab = new Rabbit();
        Tortoise tor = new Tortoise();
        //调用start方法 ，启动线程。 内部由CPU管控
        rab.start(); //不要调用run方法，由内部自己调用。
        tor.start();
        for(int i=0;i<30;i++)
        {
            System.out.println("main-->"+i);
        }
    }
}

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

}

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

程序中的@Override是什么意思？

@Override是Java5的元数据，自动加上去的一个标志，告诉你说下面这个方法是从父类/接口继承过来的，需要你重写一次，这样就可以方便你阅读，也不怕会忘记

@Override是伪代码,表示重写(当然不写也可以),不过写上有如下好处:
1>可以当注释用,方便阅读

2>编译器可以给你验证@Override下面的方法名是否是你父类中所有的,如果没有则报错

比如你如果没写@Override而你下面的方法名又写错了,这时你的编译器是可以通过的(它以为这个方法是你的子类中自己增加的方法)

使用该标记是为了增强程序在编译时候的检查，如果该方法并不是一个覆盖父类的方法，在编译时编译器就会报告错误。

rab.start(); //不要调用run方法，由内部自己调用。

start是 Tread类中的一个方法，会自动调用run（）方法：

public synchronized void start() {
        /**
         * This method is not invoked for the main method thread or "system"
         * group threads created/set up by the VM. Any new functionality added
         * to this method in the future may have to also be added to the VM.
         *
         * A zero status value corresponds to state "NEW".
         */
        if (threadStatus != 0)
            throw new IllegalThreadStateException();

        /* Notify the group that this thread is about to be started
         * so that it can be added to the group's list of threads
         * and the group's unstarted count can be decremented. */
        group.add(this);

        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
                /* do nothing. If start0 threw a Throwable then
                  it will be passed up the call stack */
            }
        }
    }

    private native void start0();

    /**
     * If this thread was constructed using a separate
     * <code>Runnable</code> run object, then that
     * <code>Runnable</code> object's <code>run</code> method is called;
     * otherwise, this method does nothing and returns.
     * <p>
     * Subclasses of <code>Thread</code> should override this method.
     *
     * @see     #start()
     * @see     #stop()
     * @see     #Thread(ThreadGroup, Runnable, String)
     */
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }

而该例子中的内部类已经重写了run 方法；

（2）实现Runnable接口，并将对象实例作为参数传递给Thread类的构造方法：

启动：使用静态代理
1)、创建真实角色
2)、创建代理角色
3)、调用start()方法启动线程
优点：可以同时实现继承，Runnable接口方式更加通用一些。
1、避免单继承的局限性
2、便于共享资源
通过实现Runnable接口实现多线程。

package xiancheng_creat;

/**
 * Created by Taoyongpan on 2017/5/6.
 *
 * 推荐使用Runnable创建线程
 * 1、避免单继承的局限性
 * 2、便于共享资源
 */
public class MyTread01 {

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

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

/**
 * 使用Runnable 创建进程
 * 1、类实现Runable接口+重写run()方法
 * 2、启动多线程 使用静态代理
 *      1)、创建真实角色
 *      2)、创建代理角色
 *      3)、调用start()方法 启动线程
 */
class Programmer implements Runnable{
    @Override
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println("一边敲代码");
        }
    }
}

package xiancheng_creat;

/**
 * Created by Taoyongpan on 2017/5/6.
 * 抢票系统
 * 方便共享资源
 */
public class MyTread02 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) {
        //真实角色
        MyTread02 web = new MyTread02();
        //代理
        Thread t1 = new Thread(web,"t00t");
        Thread t2 = new Thread(web,"t11t");
        Thread t3 = new Thread(web,"t22t");

        //启动线程
        t1.start();
        t2.start();
        t3.start();
    }
}

附加：前两种创建线程的区别：

//继承	Tread类

MyThread extends Thread{
    @overwrite
    public void run(){
    业务流程
    }
}
public static void main(String[] args){
    MyThread mt = new MyTread();
    mt.start();
}

//实现Runnable接口

MyThread implements Runnable{
    @overwrite
    public void run(){
    业务流程
    }
}
public static void main(String[] args){
    MyThread mt = new MyTread();
    Thread td = new Thread(mt);
    td.start();
}

从代码的角度来说，实现Runnable接口比继承Thread，多了一个步骤，把要干的事塞进了一线程里（可以这么理解）
但是Java是一种单继承语言，用Runnable接口就摆脱了这种缺陷，并且，对于同一个资源的消耗来说，要用Runnable接口，继承Thread类无法处理对相同资源处理的情况，即Runnable的代码，可以被多个线程（Thread实例）共享。

package xiancheng_creat;

/**
 * Created by Taoyongpan on 2017/5/6.
 */
public class MyThread03 extends Thread {

    private int ticket = 5;  //总票数
    private String name;  //窗口号
    public MyThread03(String name) {
        this.name=name;
    }
    @Override
    public void run() {
        while(ticket>0){
            ticket--;
            System.out.println(name+"买了1张票，剩余票数为："+ticket);
        }
    }

}
class TicketThread {


    public static void main(String[] args) {
        //创建三个线程来模拟三个售票窗口
        MyThread03 mt1 = new MyThread03("窗口1");
        MyThread03 mt2 = new MyThread03("窗口2");
        MyThread03 mt3 = new MyThread03("窗口3");
        mt1.start();
        mt2.start();
        mt3.start();
    }

}
运行结果：
窗口3买了1张票，剩余票数为：4
窗口3买了1张票，剩余票数为：3
窗口3买了1张票，剩余票数为：2
窗口3买了1张票，剩余票数为：1
窗口3买了1张票，剩余票数为：0
窗口1买了1张票，剩余票数为：4
窗口2买了1张票，剩余票数为：4
窗口1买了1张票，剩余票数为：3
窗口2买了1张票，剩余票数为：3
窗口2买了1张票，剩余票数为：2
窗口2买了1张票，剩余票数为：1
窗口2买了1张票，剩余票数为：0
窗口1买了1张票，剩余票数为：2
窗口1买了1张票，剩余票数为：1
窗口1买了1张票，剩余票数为：0

package xiancheng_creat;

/**
 * Created by Taoyongpan on 2017/5/6.
 * 抢票系统
 * 方便共享资源
 */
public class MyThread02 implements Runnable {
    private int num = 5;
    @Override
    public void run() {
        while(true){
            if(num<=0)
            {
                break;//跳出循环
            }
            System.out.println(Thread.currentThread().getName()+"剩余"+num--+"张。");
        }
    }

    public static void main(String[] args) {
        //真实角色
        MyThread02 web = new MyThread02();
        //创建三个线程来模拟三个售票窗口//Thread有种默认的构造方法，可以这样创建线程时给线程起名
        Thread t1 = new Thread(web,"窗口1");
        Thread t2 = new Thread(web,"窗口2");
        Thread t3 = new Thread(web,"窗口3");

        //启动线程
        t1.start();
        t2.start();
        t3.start();
    }
}

运行结果：
窗口3剩余5张。
窗口2剩余4张。
窗口2剩余1张。
窗口1剩余3张。
窗口3剩余2张。

继承Thread相当于创建了三个进程模拟三个窗口，无法实现资源共享；而实现Runable接口也是创建三个进程来模拟三个窗口，并且可以实现资源共享，三个线程的总共票数为五张

如果把实现Runable接口的创建线程部分改为如下，则和继承Thread类的效果一样：

public static void main(String[] args) {
        MyThreadr mt1 = new MyThreadr();
        MyThreadr mt2 = new MyThreadr();
        MyThreadr mt3 = new MyThreadr();
        //创建三个线程来模拟三个售票窗口
        //Thread有种默认的构造方法，可以这样创建线程时给线程起名
        Thread td1 = new Thread(mt1,"窗口1");
        Thread td2 = new Thread(mt2,"窗口2");
        Thread td3 = new Thread(mt3,"窗口3");
        td1.start();
        td2.start();
        td3.start();
    }

（3）实现callable接口，并实现call方法，并且线程执行完毕后会有返回值。

Callable 和 Future接口
Callable是类似于Runnable的接口，实现*Callable接口的类和实现Runnable的类都是可被其它线程执行的任务*。
优点：可以返回值，可以抛异常。
缺点：实现繁琐。

步骤：
1、实现Callable接口+重写call方法

2、借助执行调度服务ExecutorService获取Future对象

ExecutorService ser = Executors.newFixedThreadPool(2);
Future<Integer> result= ser.submit(tortoise);

3、获取值result

int num = result.get(); get方法返回值是一个泛型

4、停止服务ser.shutdownNow();

完整代码：

package xiancheng_creat;

import java.util.concurrent.*;

/**
 * Created by Taoyongpan on 2017/5/6.
 * 使用Callable接口方式创建多线程
 */
public class MyThread04 {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        //1、创建线程
        ExecutorService ser = Executors.newFixedThreadPool(2);//开两个线程

        Race tortoise = new Race("老乌龟",1000);
        Race rabbit = new Race("小兔子",500);

        //2、获取Future对象
        Future<Integer> result1 = ser.submit(tortoise);
        Future<Integer> result2 = ser.submit(rabbit);

        Thread.sleep(2000);//2秒
        tortoise.setFlag(false);//停止线程体循环 设置flag = false;
        rabbit.setFlag(false);
        //3、获取值
        int num1 = result1.get();
        int num2 = result2.get();

        System.out.println("乌龟跑了-->"+num1+"步");
        System.out.println("兔子跑了-->"+num2+"步");
        //4、停止服务
        ser.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) {
        super();
        this.name = name;
    }
    public Race(String name, int time) {
        super();
        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;
    }
}

Callable和Runnable有几点不同：

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

（2）Callable的任务执行后可返回值，而Runnable的任务是不能返回值的。

（3）call()方法可抛出异常，而run()方法是不能抛出异常的。

（4）运行Callable任务可拿到一个Future对象，Future表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。通过Future对象可了解任务执行情况，可取消任务的执行，还可获取任务执行的结果。

分享到：

extents和implements的区别 | Java使用static的方法和类与不使用的区别

2017-05-06 16:27
浏览 474
评论(0)
分类:编程语言
查看更多

发表评论

您还没有登录,请您登录后再发表评论

最近访客更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论

线程的三种重建

程序中的@Override是什么意思？

Callable和Runnable有几点不同：

评论

发表评论

相关推荐

最近访客 更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论

线程的三种重建

程序中的@Override是什么意思？

Callable和Runnable有几点不同：

评论

发表评论

相关推荐

HelloWorld引发的思考

解决hash冲突的四种常用方法

堆栈的区别

try,catch,finally测试

"a".equals(a)和a.equals("a")

java运算符优先级

HashMap 源码分析

传统IO与NIO的Socket编程

三次握手与四次挥手

Java内存泄露与溢出

阿里巴巴Java开源项目

Java程序的编译与运行

extents和implements的区别

Java使用static的方法和类与不使用的区别

servlet初步学习

线程与进程学习（一）

public、private、protected、default和 static

Java集合——Set，Map

Java逻辑运算

深入分析Java I/O的工作机制

最近访客更多访客>>