Java中多线程的创建

 多线程的创建

方法一：继承于Thread类

1.遍历100以内的所有偶数

/*
 *多线程的创建
 *一.继承于Thread类
 *1.创建一个Thread类的子类
 *2.重写Thread类的run()->将此线程执行的操作声明在run()方法中
 *3.创建Thread类的子类的对象
 *4.通过此对象调用start():(1)启动当前线程(2)调用当前线程的run()方法
 */
//遍历100以内的所有偶数

class MyThread extends Thread
{
    @Override//重写run()
    public void run() {
        for(int i=0;i<100;i++)
        {
            if((i&1)==1)
                System.out.println(i);
        }
    }
}
public class test {
public static void main(String[] args) {
    MyThread t1=new MyThread();//在主线程中建立子类对象
    t1.start();//对象调用start()方法，第二个线程开始执行
    //t1.run();如果调用run则不会使用多个进程
    //如果还想再执行start(),不能用已经执行过start()的进程的对象，否则会报IllegalThreadStateException，可以再重新创建一个类对象
    MyThread t2=new MyThread();
    t2.start();
    //第二个执行的同时，主线程执行下面过程
    for(int i=0;i<100;i++)
    {
        if((i&1)==0)
            System.out.println("*"+i+"*");
    }
}
}

 

2.建立两个线程，分别遍历100以内的所有偶数和奇数

//建立两个线程，分别遍历100以内的所有偶数和奇数
//可以通过创建Thread匿名子类的方法
class MyThread extends Thread
{
    @Override//重写run()
    public void run() {
        /*for(int i=0;i<100;i++)
        {
            if((i&1)==1)
                System.out.println(i);
        }*/
    }
}
public class test {
public static void main(String[] args) {
    
    new Thread() {
        public void run() {
            for(int i=0;i<100;i++)
            {
                if((i&1)==1)
                    System.out.println(i);
            }
        }
    }.start();
    for(int i=0;i<100;i++)
    {
        if((i&1)==0)
            System.out.println("*"+i+"*");
    }
    new Thread() {
         public void run() {
                for(int i=0;i<100;i++)
                {
                    if((i&1)==0)
                        System.out.println("*"+i);
                }
            }
    }.start();
}
}

 

方法二：实现Runnable接口

/*
 * 创建多线程的方式二：实现Runnable接口
 * 1.创建一个类实现Runnable接口
 * 2.实现类去实现Runnable中的抽象方法:run()
 * 3.创建实现类的对象
 * 4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
 * 5.通过Thread类的对象调用start()
 */
class MyThread implements Runnable
{
    public void run()
    {
        for(int i=0;i<100;i++)
        {
            if((i&1)==0)
            {
                System.out.println(Thread.currentThread().getName()+i);
            }
        }
    }
}

/*源码
   target定义
      //What will be run. 
   private Runnable target;

   Thread的构造器
     public Thread(Runnable target) {
       init(null, target, "Thread-" + nextThreadNum(), 0);
    }
    
   重写run()
        @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }

 */
public class test {
    public static void main() {
MyThread mythread=new MyThread();
Thread t1=new Thread(mythread);
/*
 * 通过Thread类的对象调用start():(1)启动线程(2)调用当前线程的run()
 * t1.start()其实调用了当前线程的run()
 * 通过看上面的源码发现即调用Runnable类型的target的run
 * 也就是这里的MyThread.run()
 */
t1.start();
Thread t2=new Thread(mythread);
t2.start();
}
}

 

两种创建线程的方法比较：

开发中优先选择实现Runnable接口的方式

原因：

1.实现的方式没有类的单继承的局限性

2.实现的方式更适合来处理多个线程有共享数据的情况

 

联系：Thread类本身也实现了Runnable接口 public class Thread implements Runnable

相同点：两种方式都需要重写run(),将线程要执行的逻辑声明在run()方法中。