1. 
   
2. 实现多线程的第一种方法,让一个类继承Thread类
   
3. class A extends Thread
   
4. {
   
5. 　　覆盖run方法;
   
6. }
   
7. 
   
8. 实现多线程的第二种方法,让一个类实现Runnable接口
   
9. class B implements Runnable
   
10. {
    
11. 　　实现run方法;
    
12. }
    
13. 以上两种方式的优劣,教学视频里是这么说的:
    
14. 实现方式和继承方式有什么区别？
    
15. 
    
16. 实现方式好处：避免的了单继承的局限性
    
17. 在定义线程时，建议使用实现方式。
    
18. 
    
19. 两种方式区别：
    
20. 继承Thread：线程代码存放Thread子类的run方法中
    
21. 实现Runnable：线程代码存在接口的子类的run方法中
    
22. 
    
23. 那么我的问题是:
    
24. 在函数内实现多线程:如下
    
25. public class C
    
26. {
    
27. 　　public static void main()
    
28. 　　{
    
29. 　　Thread th = new Thread()
    
30. 　　{
    
31. 　　覆盖run方法;
    
32. 　　};
    
33. 　　
    
34. 　　Runnable rb = new Runnable()
    
35. 　　{
    
36. 　　实现run方法;
    
37. 　　};
    
38. 　　
    
39. 　　th.start();
    
40. 　　new Thread(rb),start();
    
41. 　　}
    
42. }
    
43. 我想问的是以上两个实现多线程的方法有什么区别和优劣?

复制代码

首先你的代码有错误应该是这样的
        代码体现：

                        public class RunnableDemo implements Runnable
                        {
                                public void run()
                                {
                                        //code
                                }
                        }

                        public class RunnableDemoTest
                        {
                                public static void main(String[] args)
                                {
                                        RunnableDemo rd = new RunnableDemo();

                                        Thread t1 = new Thread(rd);
                                        Thread t2 = new Thread(rd);

                                        t1.start();
                                        t2.start();
                                }
                        }
两个实现多线程的方法有什么区别和优劣?
区别在于  一个是对象名调用方法名   一个是匿名对象调用方法名
优劣  就应该是 匿名对象调用方法比较节省内存空间

方志亮 发表于 2012-8-20 18:48
首先你的代码有错误应该是这样的
        代码体现：

1. 25.public class C
   
2. 
   
3. 26.{
   
4. 
   
5. 27.　　public static void main()
   
6. 
   
7. 28.　　{
   
8. 
   
9. 29.　　Thread th = new Thread()
   
10. 
    
11. 30.　　{
    
12. 
    
13. 31.　　覆盖run方法;
    
14. 
    
15. 32.　　};
    
16. 
    
17. 33.　　
    
18. 
    
19. 34.　　Runnable rb = new Runnable()
    
20. 
    
21. 35.　　{
    
22. 
    
23. 36.　　实现run方法;
    
24. 
    
25. 37.　　};
    
26. 
    
27. 38.　　
    
28. 
    
29. 39.　　th.start();
    
30. 
    
31. 40.　　new Thread(rb),start();
    
32. 
    
33. 41.　　}
    
34. 
    
35. 42.}
    

复制代码

哥们,看清楚我的问题,我要问的是这个函数两个实现多线程的方法有什么区别和优劣

说说我的看法吧。比如说卖票吧，得用到多线程吧，又想继承一个"人"类。由于java是单继承 所以继承Thread 这种创建方法不合适。 处理同一数据时，继承Thread： static 生命周期太长，实现Runnable比较合适

杨鹏鹏 发表于 2012-8-20 19:44
说说我的看法吧。比如说卖票吧，得用到多线程吧，又想继承一个"人"类。由于java是单继承 所以继承Thread  ...

你这个我知道的,那是单独创建类的情况
我想知道的是,不单独创建类,在一个函数内用匿名内部类的方式实现多线程,
那么两种方法有什么区别不?

两个实现多线程的方法有什么区别和优劣?
区别在于  一个是对象名调用方法名   一个是匿名对象调用方法名
优劣  就应该是 匿名对象调用方法比较节省内存空间

方志亮 发表于 2012-8-20 21:56
两个实现多线程的方法有什么区别和优劣?
区别在于  一个是对象名调用方法名   一个是匿名对象调用方法名
优 ...

1. 那么我的问题是:
   
2. 
   
3. 在函数内实现多线程:如下
   
4. 
   
5. public class C
   
6. 
   
7. {
   
8. 
   
9. 　　public static void main()
   
10. 
    
11. 　　{
    
12. 
    
13. 　　Thread th = new Thread()
    
14. 
    
15. 　　{
    
16. 
    
17. 　　覆盖run方法;
    
18. 
    
19. 　　};
    
20. 
    
21. 　　
    
22. 
    
23. 　　Runnable rb = new Runnable()
    
24. 
    
25. 　　{
    
26. 
    
27. 　　实现run方法;
    
28. 
    
29. 　　};
    
30. 
    
31. 　　
    
32. 
    
33. 　　th.start();
    
34. 
    
35. 　　new Thread(rb),start();
    
36. 
    
37. 　　}
    
38. 
    
39. }
    
40. 
    
41. 我想问的是这个函数内两种匿名方式有什么区别?
    

复制代码