java中的多线程.docx

java中的多线程.docx

《java中的多线程.docx》由会员分享，可在线阅读，更多相关《java中的多线程.docx（35页珍藏版）》请在冰豆网上搜索。

java中的多线程

java中的多线程

在java中要想实现多线程，有两种手段，一种是继续Thread类，另外一种是实现Runable接口。

对于直接继承Thread的类来说，代码大致框架是：

?

1

2

3

4

5

6

7

8

9

10

11

12

class类名extendsThread{

方法1;

方法2；

…

publicvoidrun（）{

//othercode…

}

属性1；

属性2；

…

}

先看一个简单的例子：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

/**

 *@authorRollen-Holt继承Thread类,直接调用run方法

 **/

classhelloextendsThread{

    publichello（）{

    }

     publichello（Stringname）{

        this.name=name;

    }

    publicvoidrun（）{

        for（inti=0;i<5;i++）{

            System.out.println（name+"运行    "+i）;

        }

    }

     publicstaticvoidmain（String[]args）{

        helloh1=newhello（"A"）;

        helloh2=newhello（"B"）;

        h1.run（）;

        h2.run（）;

    }

     privateStringname;

}

【运行结果】：

A运行0A运行1A运行2A运行3A运行4B运行0B运行1B运行 2B运行3B运行4

我们会发现这些都是顺序执行的，说明我们的调用方法不对，应该调用的是start（）方法。

当我们把上面的主函数修改为如下所示的时候：

?

1

2

3

4

5

6

publicstaticvoidmain（String[]args）{

        helloh1=newhello（"A"）;

        helloh2=newhello（"B"）;

        h1.start（）;

        h2.start（）;

    }

然后运行程序，输出的可能的结果如下：

A运行   0B运行   0B运行   1B运行  2B运行    3B运行    4

A运行    1A运行    2A运行  3A运行  4

因为需要用到CPU的资源，所以每次的运行结果基本是都不一样的，呵呵。

注意：

虽然我们在这里调用的是start（）方法，但是实际上调用的还是run（）方法的主体。

那么：

为什么我们不能直接调用run（）方法呢？

我的理解是：

线程的运行需要本地操作系统的支持。

如果你查看start的源代码的时候，会发现：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

publicsynchronizedvoidstart（）{

        /**

     *Thismethodisnotinvokedforthemainmethodthreador"system"

     *groupthreadscreated/setupbytheVM.Anynewfunctionalityadded

     *tothismethodinthefuturemayhavetoalsobeaddedtotheVM.

     *Azerostatusvaluecorrespondstostate"NEW".        */

        if（threadStatus!

=0||this!

=me）

            thrownewIllegalThreadStateException（）;

        group.add（this）;

        start0（）;

        if（stopBeforeStart）{

        stop0（throwableFromStop）;

    }

}

privatenativevoidstart0（）;

注意我用红色加粗的那一条语句，说明此处调用的是start0（）。

并且这个这个方法用了native关键字，次关键字表示调用本地操作系统的函数。

因为多线程的实现需要本地操作系统的支持。

但是start方法重复调用的话，会出现java.lang.IllegalThreadStateException异常。

通过实现Runnable接口：

 大致框架是：

1

2

3

4

5

6

7

8

9

10

11

12

class类名implementsRunnable{

方法1;

方法2；

…

publicvoidrun（）{

//othercode…

}

属性1；

属性2；

…

}

 来先看一个小例子吧：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

/**

 *@authorRollen-Holt实现Runnable接口 **/

classhelloimplementsRunnable{

    publichello（）{

    }

     publichello（Stringname）{

        this.name=name;

    }

    publicvoidrun（）{

        for（inti=0;i<5;i++）{

            System.out.println（name+"运行    "+i）;

        }

    }

    publicstaticvoidmain（String[]args）{

        helloh1=newhello（"线程A"）;

        Threaddemo=newThread（h1）;

        helloh2=newhello（"线程Ｂ"）;

        Threaddemo1=newThread（h2）;

        demo.start（）;

        demo1.start（）;

    }

    privateStringname;

}

【可能的运行结果】：

线程A运行 0线程Ｂ运行    0线程Ｂ运行    1线程Ｂ运行    2

线程Ｂ运行 3线程Ｂ运行   4线程A运行    1

线程A运行    2线程A运行    3线程A运行    4

关于选择继承Thread还是实现Runnable接口？

其实Thread也是实现Runnable接口的：

1

2

3

4

5

6

7

8

classThreadimplementsRunnable{

    //…

publicvoidrun（）{

        if（target!

=null）{

             target.run（）;

        }

        }

}

其实Thread中的run方法调用的是Runnable接口的run方法。

不知道大家发现没有，Thread和Runnable都实现了run方法，这种操作模式其实就是代理模式。

关于代理模式，我曾经写过一个小例子呵呵，大家有兴趣的话可以看一下：

Thread和Runnable的区别：

如果一个类继承Thread，则不适合资源共享。

但是如果实现了Runable接口的话，则很容易的实现资源共享。

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

/**

 *@authorRollen-Holt继承Thread类，不能资源共享

 **/

classhelloextendsThread{

    publicvoidrun（）{

        for（inti=0;i<7;i++）{

            if（count>0）{

                System.out.println（"count="+count--）;

            }

        }

    }

    publicstaticvoidmain（String[]args）{

        helloh1=newhello（）;

        helloh2=newhello（）;

        helloh3=newhello（）;

        h1.start（）;

        h2.start（）;

        h3.start（）;

    }

    privateintcount=5;

}

【运行结果】：

count=5

count=4

count=3

count=2

count=1

count=5

count=4

count=3

count=2

count=1

count=5

count=4

count=3

count=2

count=1

大家可以想象，如果这个是一个买票系统的话，如果count表示的是车票的数量的话，说明并没有实现资源的共享。

我们换为Runnable接口

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

classMyThreadimplementsRunnable{

    privateintticket=5; //5张票

    publicvoidrun（）{

        for（inti=0;i<=20;i++）{

            if（this.ticket>0）{

                System.out.println（Thread.currentThread（）.getName（）+"正在卖票"+this.ticket--）;

            }

        }

    }

}

publicclasslzwCode{