Java中的多线程

分类： java2012-09-26
11:17 365人阅读 评论(0) 收藏 举报

java任务threadexception多线程string

一、提要

java中的多线程算是java中的一个 很大的难点 ，虽然 看了 很多书 ，相信对于 很多 接触 java不够 深的人来说 ，多线程永远都是心中的痛！

今天我们 就 通过大量的 例子 来 彻底把它征服 .

二、Runable接口

实现 Runable接口 是 实现多线程 的 一种方法。看例子 

[java] view
plaincopy

<span style="font-size:14px;">package thread;  

public class LiftOff implements Runnable {  

protected int countDown = 10; // Default  

private static int taskCount = 0;  

private final int id = taskCount++;  

public LiftOff() {}  

public LiftOff(int countDown) {  

this.countDown = countDown;  

}  

public String status() {  

return "#" + id + "(" +  

(countDown > 0 ? countDown : "Liftoff!") + "), ";  

}  

public void run() {  

while(countDown-- > 0) {  

System.out.print(status());  

Thread.yield();  

}  

}  

} </span>  

这个类的实现了 一个线程 ：implements了Runable接口 ，实现了 run方法。

通常情况下，run方法中都会有意个循环 ，直到任务结束的时候才会跳出来。

线程的主要任务是循环十次，每次打印出 终端 状态。Thread.yield()的作用是如果线程队列中有线程等待，则阻塞自己，

将资源 交给 下一个等待的线程。

在main函数中 调用如下：

[java] view
plaincopy

<span style="font-size:14px;">package thread;  

public class Main {  

public static void main(String[] arges)  

{  

LiftOff tmp=new LiftOff();  

tmp.run();  

System.out.println("Waiting for LiftOff");  

}  

}  

</span>  

将类型初始化实例时候 ，直接 调用run方法，线程就会开始运行。

运行结果：

#0(9), #0(8), #0(7), #0(6), #0(5), #0(4), #0(3), #0(2), #0(1), #0(Liftoff!), Waiting for LiftOff

这里实际上并没有线程的概念，只是用到了一些简单的函数调用。

真正的线程需要将Runable装到一个Thread中去。

三、Thread实例

传统的使用Runable对象的方法就是把它作为一个参数传给Thread的构造函数作为参数，然后调用Thread的start()方法来启动线程。

start()方法对Runale进行 了 一些 必要的初始化，然后调用Runable的run方法。

将原main函数改写如下：

[java] view
plaincopy

<span style="font-size:14px;">package thread;  

public class Main {  

public static void main(String[] arges)  

{  

Thread t = new Thread(new LiftOff());  

t.start();  

System.out.println("Waiting for LiftOff");  

  

  

}  

}</span>  

运行结果：

Waiting for LiftOff

#0(9), #0(8), #0(7), #0(6), #0(5), #0(4), #0(3), #0(2), #0(1), #0(Liftoff!), 

运行的结果和之前的例子类似，但“Waiting for LiftOff“出现的位置不同了。

原理：在程序的第五行声明了一个线程，并初始化，一个LiftOff对象作为参数传进去。

第六行通过线程调用启动了t线程，但main线程还可以继续干自己的事，cpu给的时间片还没用完，于是“Waiting for LiftOff”就先被打印出来了，之后时间片被用完了，资源交给t线程，运行的内容被打印出来了。

下面是在main中启动多个线程：

[java] view
plaincopy

<span style="font-size:14px;">package thread;  

public class Main {  

  

  

public static void main(String[] arges)  

{  

for(int i = 0; i < 5; i++)  

new Thread(new LiftOff()).start();  

System.out.println("Waiting for LiftOff");  

}  

}</span>  

修改一下LiftOff类：

[java] view
plaincopy

<span style="font-size:14px;">package thread;  

public class LiftOff implements Runnable {  

private static int taskCount = 0;  

private final int id = taskCount++;  

public LiftOff() {}  

public void run() {  

System.out.println("startThreadId: " + id);  

try {  

Thread.sleep(1000);  

} catch (InterruptedException ignored) {  

}  

System.out.println("endTHreadId: " + id);  

}  

} </span>  

运行结果：

startThreadId: 0

startThreadId: 1

startThreadId: 2

startThreadId: 3

Waiting for LiftOff

startThreadId: 4

endTHreadId: 0

endTHreadId: 1

endTHreadId: 2

endTHreadId: 3

endTHreadId: 4

运行的结果反映了多线程运行的时候线程的调度。调度的规则主要由线程管理器来决定，在多核心的计算机中，线程管理器会把线程交由不同的cpu来完成。

由于线程的调度机制并不是确定的，不同版本的jdk所得到的结果是不同的。

对于打印结果的理解：运行之后哦main线程尝试创建5个线程，但在创建#3进程的时候时间片用完了，main的Thread进入等待队列，接着时间片论转到最先进入线程队列的#0进程->#0时间片用完（线程还没销毁）->时间片轮转到#1->#1时间片用完....(看不懂的要回头学一下操作系统中进程管理的知识)。

四、使用Executors
线程池由 Executor 框架提供。 Executor 框架将处理请求任务的提交和它的执行解耦。可以制定执行策略。在线程池中执行线程可以重用已经存在的线程，而不是创建新的线程，可以在处理多请求时抵消线程创建、消亡产生的开销。
ExecutorService 的几个重要方法：
1、shutdown方法：这个方法会平滑地关闭ExecutorService，当我们调用这个方法时，ExecutorService停止接受任何新的任务且等待已经提交的任务执行完成(已经提交的任务会分两类：一类是已经在执行的，另一类是还没有开始执行的)，当所有已经提交的任务执行完毕后将会关闭ExecutorService。
2、awaitTermination方法：这个方法有两个参数，一个是timeout即超时时间，另一个是unit即时间单位。这个方法会使线程等待timeout时长，当超过timeout时间后，会监测ExecutorService是否已经关闭，若关闭则返回true，否则返回false。一般情况下会和shutdown方法组合使用

直接看代码：

[java] view
plaincopy

<span style="font-size:14px;">package thread;  

import java.util.concurrent.ExecutorService;  

import java.util.concurrent.Executors;  

public class Main {  

  

  

public static void main(String[] arges)  

{  

//ExecutorService exec = Executors.newSingleThreadExecutor();  

ExecutorService exec = Executors.newFixedThreadPool(3);  

for(int i = 0; i <5; i++)  

{  

try{  

exec.execute(new LiftOff());  

//Thread.sleep(1000);  

}catch(Exception e)  

{  

e.printStackTrace();  

}  

}  

exec.shutdown();  

System.out.println("Waiting for LiftOff");  

}  

}</span>  

运行结果：

startThreadId: 0

startThreadId: 1

Waiting for LiftOff

startThreadId: 2

endThreadId: 0       

startThreadId: 3

endThreadId: 1       

startThreadId: 4

endThreadId: 2       

endThreadId: 3       

endThreadId: 4       

newCachedThreadPool()创建一个可根据需要创建新线程的线程池，newSingleThreadExecutor（）约等于newFixedThreadPool(1)

SingleThreadExecutor运行结果：

Waiting for LiftOff

startThreadId: 0

endThreadId: 0       

startThreadId: 1

endThreadId: 1       

startThreadId: 2

endThreadId: 2       

startThreadId: 3

endThreadId: 3       

startThreadId: 4

endThreadId: 4       

    

CachedThreadPool运行结果：

startThreadId: 0

startThreadId: 1

startThreadId: 2

startThreadId: 3

Waiting for LiftOff

startThreadId: 4

endThreadId: 0       

endThreadId: 1       

endThreadId: 2       

endThreadId: 3       

endThreadId: 4       

     

Executors还是有点难理解，需要很多的实战才能有更好的体会，这里点到为止。

五、Callable 和 Future接口   

 Callable是类似于Runnable的接口，实现Callable接口的类和实现Runnable的类都是可被其它线程执行的任务。   

 Callable和Runnable有几点不同：   

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

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

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

（4）运行Callable任务可拿到一个Future对象，   

 Future 表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。   

 通过Future对象可了解任务执行情况，可取消任务的执行，还可获取任务执行的结果。   

代码示例：

[java] view
plaincopy

<span style="font-size:14px;">import java.util.concurrent.Callable;  

import java.util.concurrent.ExecutorService;  

import java.util.concurrent.Executors;  

import java.util.concurrent.Future;  

public class CallableTest {  

    /** *//**    

     * 自定义一个任务类，实现Callable接口    

     */      

    public static class MyCallableClass implements Callable{       

        // 标志位       

        private int flag = 0;       

        public MyCallableClass(int flag){       

            this.flag = flag;       

        }       

        public String call() throws Exception{       

            if (this.flag == 0){       

                // 如果flag的值为0，则立即返回       

                return "flag = 0";       

            }        

            if (this.flag == 1){       

                // 如果flag的值为1，做一个无限循环       

                try {       

                    while (true) {       

                        System.out.println("looping.");       

                        Thread.sleep(2000);       

                    }       

                } catch (InterruptedException e) {    

                //如果线程被终止，打印提示  

                    System.out.println("Interrupted");       

                }       

                return "false";       

            } else {       

                // falg不为0或者1，则抛出异常       

                throw new Exception("Bad flag value!");       

            }       

        }       

    }       

           

    public static void main(String[] args) {       

        // 定义3个Callable类型的任务       

        MyCallableClass task1 = new MyCallableClass(0);       

        MyCallableClass task2 = new MyCallableClass(1);       

        MyCallableClass task3 = new MyCallableClass(2);       

               

        // 创建一个执行任务的服务       

        ExecutorService es = Executors.newFixedThreadPool(3);       

        try {       

            // 提交并执行任务，任务启动时返回了一个 Future对象，       

            // 如果想得到任务执行的结果或者是异常可对这个Future对象进行操作       

            Future future1 = es.submit(task1);       

            // 获得第一个任务的结果，如果调用get方法，当前线程会等待任务执行完毕后才往下执行       

            System.out.println("task1: " + future1.get());       

                   

            Future future2 = es.submit(task2);       

            // 等待5秒后，再停止第二个任务。因为第二个任务进行的是无限循环       

            Thread.sleep(6000);       

            System.out.println("task2 cancel: " + future2.cancel(true));       

                   

            // 获取第三个任务的输出，因为执行第三个任务会引起异常       

            // 所以下面的语句将引起异常的抛出       

            Future future3 = es.submit(task3);       

            System.out.println("task3: " + future3.get());       

        } catch (Exception e){       

            System.out.println(e.toString());       

        }       

        // 停止任务执行服务       

        es.shutdownNow();       

    }       

  

  

}  

</span>  

运行结果：

task1: flag = 0

looping.

looping.

looping.

task2 cancel: true

Interrupted

java.util.concurrent.ExecutionException: java.lang.Exception: Bad flag value!