Java多线程实践-优快云博客

2019独角兽企业重金招聘Python工程师标准>>>

java多线程一直是一个比较重要的内容，我这里只做简单的使用，另外回想起以前每次面试都会问到线程的使用问题，所以这里还是总结一下。深层次的内容要看下下面的java线程的系列博文，确实不错，强烈推荐。

第一种的实现方式是继承Thread类。如果一个类继承了thread，则其就具有线程的能力。但是JAVA是单继承，所以有一定的局限性

public class Test {
    public static void main(String args[]) {
        //初始化线程
        MyThread ft = new MyThread();
        //启动线程
        ft.start();
        try {
            for (int i = 0; i < 10; i++) {
                //延时1秒
                Thread.sleep(1000);
                System.out.println("main:" + i);
            }
        } catch (Exception e) {
        }
    }

    private static class MyThread extends Thread {
        public void run() {
            try {
                for (int i = 0; i < 10; i++) {
                    //延时1秒
                    Thread.sleep(1000);
                    System.out.println("run:" + i);
                }
            } catch (Exception e) {
            }
        }
    }
}

其中MyThread是一个继承了Thread的类，因此其本身就可以实现多线程，run()方法表示其实现的功能，在主函数中通过调用start()来启动多线程。这时系统有两个线程在同时执行，所以输出结果为两个数字交替出现。

另外有一点要注意是，当run方法执行完之后，自定义线程将自然死亡。

第二种方法是实现Runnable接口

public class Test {
    public static void main(String args[]) {
        //初始化线程
        MyRunnable myRunnable = new MyRunnable();
        Thread thread=new Thread(myRunnable);
        //启动线程
        thread.start();
        try {
            for (int i = 0; i < 10; i++) {
                //延时1秒
                Thread.sleep(1000);
                System.out.println("main:" + i);
            }
        } catch (Exception e) {
        }
    }

    private static class MyRunnable implements Runnable {
        public void run() {
            try {
                for (int i = 0; i < 10; i++) {
                    //延时1秒
                    Thread.sleep(1000);
                    System.out.println("run:" + i);
                }
            } catch (Exception e) {
            }
        }
    }
}

该例子中由MyRunnale实现Runnable的接口，并实现run方法。然后由Thread创建myrunnable对象。最后再条用thread对象的start方法

其实除了继承Thread和实现Runnable接口两种方式外，还有一种是使用java.util包中的Timer类和Timetask类。

Timer类似一个闹钟，本身实现的就是一个线程，可以用来调用其他线程。而TimeTask是一个抽象类，本身实现了Runnable接口，所以要写其中的run方法。然后通过Timer类来启动线程执行。

在实际使用时，一个Timer可以启动任意多个TimerTask实现的线程，但是多个线程之间会存在阻塞。所以如果多个线程之间如果需要完全独立运行的话，最好还是一个Timer启动一个TimerTask实现。

public class Test {
    public static void main(String args[]) {
        //创建Timer
        Timer t = new Timer();
        //创建TimerTask
        MyTimerTask mtt1 = new MyTimerTask("线程1：");
        //启动线程
        t.schedule(mtt1, 0);
    }

    private static class MyTimerTask extends TimerTask {
        String s;
        public MyTimerTask(String s){
            this.s = s;
        }
        public void run() {
            try{
                for(int i = 0;i < 10;i++){
                    Thread.sleep(1000);
                    System.out.println(s + i);
                }
            }catch(Exception e){}
        }
    }
}

其中Time的Schedule()方法的第一个参数代表要启动的线程对象，第二个参数代表延迟多少毫秒启动线程。为0的话表示立刻启动。

其中schedule主要有四种方法

1、 public void schedule(TimerTask task,Date time)

该方法的作用是在到达time指定的时间或已经超过该时间时执行线程task。例如假设t是Timer对象，task是需要启动的TimerTask线程对象，后续示例也采用这种约定实现，则启动线程的示例代码如下：

Date d = new Date(2009-1900,10-1,1,10,0,0); 
t. schedule(task,d);

则该示例代码的作用是在时间达到d指定的时间或超过该时间(例如2009年10月2号)时，启动线程task。

2、 public void schedule(TimerTask task, Date firstTime, long period)

该方法的作用是在时间到达firstTime开始，每隔period毫秒就启动一次task指定的线程。示例代码如下：

Date d = new Date(2009-1900,10-1,1,10,0,0);
t. schedule(task,d,20000);

该示例代码的作用是当时间达到或超过d指定的时间以后，每隔20000毫秒就启动一次线程task，这种方式会重复触发线程。

3、 public void schedule(TimerTask task,long delay)

该方法和第一个方法类似，作用是在执行schedule方法以后delay毫秒以后启动线程task。示例代码如下：

t. schedule(task,1000);

该示例代码的作用是在执行该行启动代码1000毫秒以后启动一次线程task。

4、 public void schedule(TimerTask task,long delay,long period)

该方法和第二个方法类似，作用是在执行schedule方法以后delay毫秒以后启动线程task，然后每隔period毫秒重复启动线程task。

另外Timer中还有一个scheduleAtFixedRate方法，其作用是实现重复启动线程时的精确延时

下面是Java线程系列博文的一个编目：

总结一下，java中实现多线程有继承Thread，实现Runnable及通过Timer和TimerSchedual实现。另外后面的系列博文再次推荐一下，对理解多线程非常有帮助。

转载于:https://my.oschina.net/zimingforever/blog/101152

JAVA的多线程使用