如何开启多线程

这是基础视屏上讲的很清楚的吧

开始线程时获得线程对象后进行start（）方法开始线程的，在基础视频中都有详细讲解哦，楼主要认真看视频中讲解的内容啊。

|---自定义线程
                                        class MyThread extends Thread       
                                        class MyThread implements Runnable
                                |---开启线程的方法（对应上边的两个自定义线程）       
                                        new MyThread().start();
                                        new Thread(new MyThread()).start();//这里只能这样开启，不能像Thread的子类那样

线程对象.strat()。开启

创建线程对象；
调用线程的start()方法。

1. package thread;
   
2. 
   
3. /*
   
4. * 通过分析，发现，打印出0，-1，-2等错票。
   
5. * 多线程的运行出现了安全问题。
   
6. * 问题的原因：
   
7. *                 当多条语句在操作同一个线程共享数据（tick）时，一个线程对多条语句只执行了一部分，还没有执行完。
   
8. *                 另一个线程参与进来执行。导致共享数据的错误。
   
9. *
   
10. * 解决方法：
    
11. *                 对多条错做共享数据的语句，只能让一个线程都执行完。在执行过程中其他线程不可以参与执行。
    
12. *
    
13. * java对于多线程的安全问题提供了专业的解决方式。
    
14. * 就是同步代码块：
    
15. * synchronized(对象)
    
16. * {
    
17. *                 需要被同步的代码
    
18. * }
    
19. *
    
20. * 对象如同锁，持有锁的线程可以在同步中执行。
    
21. * 没有持有锁的线程即使获取CPU的执行权，也进不去，因为没有获取锁。
    
22. * 例子： 火车上的厕所————经典
    
23. *
    
24. * 同步的前提：
    
25. * 1，必须要有两个或者两个以上的线程。
    
26. * 2，必须是多个线程使用同一个锁。
    
27. * 必须保证同步中只能有一个线程在运行。
    
28. *
    
29. * 好处：解决多线程的安全问题。
    
30. * 弊端：多个线程都要判断锁，比较消耗资源。
    
31. */
    
32. class Tickets implements Runnable {
    
33.         private int tick = 100;
    
34.         Object obj = new Object();
    
35. 
    
36.         public void run() {
    
37. 
    
38.                 while (true) {
    
39.                         synchronized (obj) {
    
40.                                 if (tick > 0) {
    
41.                                         try {
    
42.                                                 Thread.sleep(10);
    
43.                                         } catch (InterruptedException e) {
    
44.                                                 e.printStackTrace();
    
45.                                         }
    
46.                                         System.out.println(Thread.currentThread().getName()
    
47.                                                         + "Sale...:" + tick--);
    
48.                                 }
    
49.                         }
    
50.                 }
    
51.         }
    
52. }
    
53. 
    
54. public class SynchronizedDemo {
    
55. 
    
56.         public static void main(String[] args) {
    
57.                 Tickets t = new Tickets();
    
58.                 Thread t1 = new Thread(t);// 创建一个线程
    
59.                 Thread t2 = new Thread(t);
    
60.                 Thread t3 = new Thread(t);
    
61.                 Thread t4 = new Thread(t);
    
62.                 t1.start();
    
63.                 t2.start();
    
64.                 t3.start();
    
65.                 t4.start();
    
66.         }
    
67. }
    

复制代码

上面是毕老师讲锁的时候的一部分代码，主方法内的t1,t2,t3,t4就是4个线程对象，分别调用start()方法，启动线程

写一个子类继承Thread类，重写run方法，创建n个子类对象，调用start()方法就开启多线程了。
package thread;

public class ThreadDemo3 extends Thread{
        public ThreadDemo3(){}
        public ThreadDemo3(String name){
                super(name);
               
        }
        public void run(){
                for(int x=0;x<1000;x++){
                System.out.println(getName()+"--"+x);
                }
        }
       
}


public class ThreadDemoTest3 {

        /**
         * @param args
         */
        public static void main(String[] args) {
                ThreadDemo3 t=new ThreadDemo3("张飞");
                ThreadDemo3 t1=new ThreadDemo3("光宇");
                ThreadDemo3 t2=new ThreadDemo3("曹操");
                t.start();
                t1.start();
                t2.start();
        }       

}