Day33（线程的创建方式一，Thread类，继承重写Thread类的run方法，start方法启动，通过创建Thread类的匿名子类创造线程）

线程的创建和启动

Java语言的JVM允许程序运行多个线程，它通过java.lang.Thread类来体现。

Thread类的特性

• 每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常把run()方法的主体称为线程体

• 通过该Thread对象的start()方法来启动这个线程，而非直接调用run()

Tread类

构造器

• Thread()：创建新的Thread对象

• Thread(String threadname)：创建线程并指定线程实例名

• Thread(Runnabletarget)：指定创建线程的目标对象，它实现了Runnable接口中的run方法

• Thread(Runnable target, String name)：创建新的Thread对象

API中创建线程的两种方式

JDK1.5之前创建新执行线程有两种方法：

• 继承Thread类的方式

• 实现Runnable接口的方式

方式一：继承Thread类

/**
 * 多线程的创建：方式一：继承于Thread类
 * 1. 创建一个继承于Thread类的子类
 * 2. 重写Thread类的run()
 * 3. 创建Thread类的子类的对象
 * 4. 通过此对象调用start()
 *
 * 例子：遍历100以内的所有偶数
 */

//1. 创建一个继承于Thread类的子类
class MyThread extends Thread{
// 2. 重写Thread类的run()
    @Override
    public void run() {
        int b=1;
        for (int i = 1; i <= 100; i++) {
        if(i % 2 == 0){b++;
        System.out.print(i+"\t");
        }if (b % 6 == 0){
        System.out.println();
        b = 1;
            }
        }
    }
}
public class ThreadTest {
    public static void main(String[] args) {
//3. 创建Thread类的子类的对象
        MyThread mythread01 = new MyThread();
//4. 通过此对象调用start()： start的两个作用：1，启动当前线程 2，调用当前线程的run()
        mythread01.start();
/* 在创建一个线程遍历所有的偶数：
        MyHTread mythread02 = new MyThread();
        mythread02.start();
                    */
        int b=1;
        for (int i = 1; i <= 100; i++) {
            if(i % 2 == 0){b++;
                System.out.print(i+"主线程\t");
            }if (b % 6 == 0){
                System.out.println();
                b = 1;
            }
        }
    }
}
run：
2主线程	2	4	6	8	10	
12	14	16	18	20	
22	24	26	28	4主线程	30	
6主线程	32	34	36	38	40	
42	44	46	48	50	
52	54	56	58	60	
62	64	66	68	8主线程	10主线程	
12主线程	14主线程	16主线程	18主线程	20主线程	
22主线程	24主线程	26主线程	28主线程	30主线程	
32主线程	34主线程	36主线程	38主线程	40主线程	
42主线程	44主线程	46主线程	48主线程	50主线程	
52主线程	54主线程	56主线程	58主线程	60主线程	
62主线程	64主线程	66主线程	68主线程	70主线程	
72主线程	74主线程	76主线程	78主线程	80主线程	
82主线程	84主线程	86主线程	88主线程	90主线程	
92主线程	94主线程	96主线程	98主线程	100主线程	
70	
72	74	76	78	80	
82	84	86	88	90	
92	94	96	98	100	

Process finished with exit code 0  

方法一练习（线程一，遍历所以偶数；线程二，遍历所有基数）：

package com.lingxiang.multithreading;

public class ThreadDemo {
    public static void main(String[] args) {
        ThreadFirst first01 = new ThreadFirst();
        first01.start();
        ThreadSecond second01 =new ThreadSecond();
        second01.start();
    }

}

class ThreadFirst extends Thread{
    public void run(){
        int b=1;
        for (int i = 1; i <= 100; i++) {
            if(i % 2 == 0){b++;
                System.out.print(i+"线程一\t");
            }if (b % 6 == 0){
                System.out.println();
                b = 1;
            }
        }
    }
}
class ThreadSecond extends Thread{
    public void run(){
        int b=1;
        for (int i = 1; i <= 100; i++) {
            if(i % 2 != 0){b++;
                System.out.print(i+"线程二\t");
            }if (b % 6 == 0){
                System.out.println();
                b = 1;
            }
        }
    }
}

方法一练习（线程一，遍历所以偶数；线程二，遍历所有基数），创建Thread类的匿名子类的方式完成多线程：

public class ThreadDemo01 {
    public static void main(String[] args) {
//创建Thread类的匿名子类的方式
    new Thread(){
        @Override
        public void run() {
            int b=1;
            for(int i = 1; i <= 100; i++) {
                if(i % 2 == 0){b++;
                    System.out.print(i+"线程一\t");
                }if (b % 6 == 0){
                    System.out.println();
                    b = 1;
                }
            }
        }
    }.start();
        new Thread(){
            @Override
            public void run() {
                int b=1;
                for(int i = 1; i <= 100; i++) {
                    if(i % 2 != 0){b++;
                        System.out.print(i+"线程二\t");
                    }if (b % 6 == 0){
                        System.out.println();
                        b = 1;
                    }
                }
            }
        }.start();
    }
}

注意点：

1.如果自己手动调用run()方法，那么就只是普通方法，没有启动多线程模式。

2.run()方法由JVM调用，什么时候调用，执行的过程控制都有操作系统的CPU调度决定。

3.想要启动多线程，必须调用start方法。

4.一个线程对象只能调用一次start()方法启动，如果重复调用了，则将抛出以上的异常“IllegalThreadStateException”。