第一种方法:继承 Thread 类

步骤:1、定义一个线程类 A 继承于 java.lang.Thread 类

   2、在 A 类中覆盖 Thread 类的 run() 方法

   3、在 run() 方法中编写需要执行的操作

   4、在 main 方法(线程)中,创建线程对象,并启动线程

      创建线程类:A类 a = new A()类;

      调用 start() 方法启动线程:a.start();

/**
 * @author: ChenHao
 * 创建多线程的第一种方式,继承java.lang.Thread类
 * @De ion:创建一个子线程,完成1-100之间自然数的输出。同样,主线程执行同样的操作
 * @Date: Created in 10:50 2018/10/29
 */
public class TestThread {
    public static void main(String [] args){
        SubThread subThread1=new SubThread();
        SubThread subThread2=new SubThread();
        //调用线程的start(),启动此线程;调用相应的run()方法
        subThread1.start();
        subThread2.start();
        //一个线程只能够执行一次start(),start()中会判断threadStatus的状态是否为0,不为0则抛出异常
        //subThread1.start();
        //不能通过Thread实现类对象的run()去启动一个线程,此时只是主线程调用方法而已,并没有启动线程
        //subThread1.run();
        for (int i=0;i<=100;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}
//1.创建一个继承Thread的子类
class SubThread extends Thread{
    //2.重写run方法,方法内实现此子线程要完成的功能
    @Override
    public void run(){
        for (int i=0;i<=100;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

注意:1、不能通过Thread实现类对象的run()去启动一个线程,此时只是主线程调用方法而已,并没有启动线程,要启动线程,必须通过Start()方法

   2、一个线程只能够执行一次start(),start()中会判断threadStatus的状态是否为0,不为0则抛出异常,所以一个线程调用两次start()会报异常

\"\"

 

第二种方法:实现 Runnable 接口

1、Runnable接口应由任何类实现,其实例将由线程执行。 该类必须定义一个无参数的方法,称为run 。 
2、该接口旨在为希望在活动时执行代码的对象提供一个通用协议。此类整个只有一个 run() 抽象方法

 

 

 

\"\"

步骤:1、定义一个线程类 A 实现于 java.lang.Runnable 接口(注意:A类不是线程类,没有 start()方法,不能直接 new A 的实例启动线程)

   2、在 A 类中覆盖 Runnable 接口的 run() 方法

   3、在 run() 方法中编写需要执行的操作

   4、在 main 方法(线程)中,创建线程对象,并启动线程

      创建线程类:Thread t = new Thread( new A类() ) ;

      调用 start() 方法启动线程:t.start();

package main.java.Thread;

/**
 * @author: ChenHao
 * @De ion:创建多线程的方式二:实现runnable
 * 对比一下继承的方式 VS 实现的方式
 * 哪个方式好?实现的方式优于继承的方式
 * why?   ①避免java单继承的局限性
 *        ②如果多个线程要操作同一份资源,更适合使用实现的方式
 * @Date: Created in 10:50 2018/10/29
 */
public class TestThread2 {
    public static void main(String [] args){
        //此程序存在线程的安全问题,打印车票时,会出现重票、错票,后面线程同步会讲到
        Window window=new Window();
        Thread thread1=new Thread(window,"窗口一");
        Thread thread2=new Thread(window,"窗口二");
        Thread thread3=new Thread(window,"窗口三");
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

class Window implements  Runnable{
    int ticket=100;
    @Override
    public void run(){
        while (true){
            if(ticket > 0){
                try {
                    Thread.currentThread().sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"售票,票号为:"+ticket--);
            }else {
                break;
            }
        }
    }
}

哪个方式好?实现的方式优于继承的方式

  why? ①避免java单继承的局限性
     ②如果多个线程要操作同一份资源,更适合使用实现的方式

注意:此程序存在线程的安全问题,打印车票时,会出现重票、错票

 第三种方法:使用匿名内部类创建线程

public static void main(String[] args) {
    for(int i = 0 ; i < 10 ; i++){
        System.out.println("玩游戏"+i);
        if(i==5){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for(int i = 0 ; i < 10 ;i++){
                        System.out.println("播放音乐"+i);
                    }
                }
            }).start();
        }
    }
}
收藏 打印