Java中多线程的创建

 1 /*
 2  *多线程的创建
 3  *一.继承于Thread类
 4  *1.创建一个Thread类的子类
 5  *2.重写Thread类的run()->将此线程执行的操作声明在run()方法中
 6  *3.创建Thread类的子类的对象
 7  *4.通过此对象调用start():(1)启动当前线程(2)调用当前线程的run()方法
 8  */
 9 //遍历100以内的所有偶数
10 
11 class MyThread extends Thread
12 {
13     @Override//重写run()
14     public void run() {
15         for(int i=0;i<100;i++)
16         {
17             if((i&1)==1)
18                 System.out.println(i);
19         }
20     }
21 }
22 public class test {
23 public static void main(String[] args) {
24     MyThread t1=new MyThread();//在主线程中建立子类对象
25     t1.start();//对象调用start()方法，第二个线程开始执行
26     //t1.run();如果调用run则不会使用多个进程
27     //如果还想再执行start(),不能用已经执行过start()的进程的对象，否则会报IllegalThreadStateException，可以再重新创建一个类对象
28     MyThread t2=new MyThread();
29     t2.start();
30     //第二个执行的同时，主线程执行下面过程
31     for(int i=0;i<100;i++)
32     {
33         if((i&1)==0)
34             System.out.println("*"+i+"*");
35     }
36 }
37 }

 1 //建立两个线程，分别遍历100以内的所有偶数和奇数
 2 //可以通过创建Thread匿名子类的方法
 3 class MyThread extends Thread
 4 {
 5     @Override//重写run()
 6     public void run() {
 7         /*for(int i=0;i<100;i++)
 8         {
 9             if((i&1)==1)
10                 System.out.println(i);
11         }*/
12     }
13 }
14 public class test {
15 public static void main(String[] args) {
16     
17     new Thread() {
18         public void run() {
19             for(int i=0;i<100;i++)
20             {
21                 if((i&1)==1)
22                     System.out.println(i);
23             }
24         }
25     }.start();
26     for(int i=0;i<100;i++)
27     {
28         if((i&1)==0)
29             System.out.println("*"+i+"*");
30     }
31     new Thread() {
32          public void run() {
33                 for(int i=0;i<100;i++)
34                 {
35                     if((i&1)==0)
36                         System.out.println("*"+i);
37                 }
38             }
39     }.start();
40 }
41 }

 1 /*
 2  * 创建多线程的方式二：实现Runnable接口
 3  * 1.创建一个类实现Runnable接口
 4  * 2.实现类去实现Runnable中的抽象方法:run()
 5  * 3.创建实现类的对象
 6  * 4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
 7  * 5.通过Thread类的对象调用start()
 8  */
 9 class MyThread implements Runnable
10 {
11     public void run()
12     {
13         for(int i=0;i<100;i++)
14         {
15             if((i&1)==0)
16             {
17                 System.out.println(Thread.currentThread().getName()+i);
18             }
19         }
20     }
21 }
22 
23 /*源码
24    target定义
25       //What will be run. 
26    private Runnable target;
27 
28    Thread的构造器
29      public Thread(Runnable target) {
30        init(null, target, "Thread-" + nextThreadNum(), 0);
31     }
32     
33    重写run()
34         @Override
35     public void run() {
36         if (target != null) {
37             target.run();
38         }
39     }
40 
41  */
42 public class test {
43     public static void main() {
44 MyThread mythread=new MyThread();
45 Thread t1=new Thread(mythread);
46 /*
47  * 通过Thread类的对象调用start():(1)启动线程(2)调用当前线程的run()
48  * t1.start()其实调用了当前线程的run()
49  * 通过看上面的源码发现即调用Runnable类型的target的run
50  * 也就是这里的MyThread.run()
51  */
52 t1.start();
53 Thread t2=new Thread(mythread);
54 t2.start();
55 }
56 }