Java线程的创建和使用及比较--娃娃都理解了

首先纠正一个错误的理解：

他的执行是一条线路

方式一：

多线程的创建：
方式一：继承于Thread类
1.创建一个继承于Thread的类的子类
2.重写Thread类的run(); —>针对方法体，将此线程执行的操作声明在run中
3.创建Thread类的子类的对象
4.通过此对象调用start()：
① 启动当前线程
② start()调用当前线程的run()方法

例子：遍历100以内的所有偶数

// 1.创建一个继承于Thread的类的子类
class MyThread extends Thread{
   // 2.重写Thread类的run();

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i%2==0){
                System.out.println(i);
            }
        }
    }
}


public class ThreadTest {
    public static void main(String[] args) {
       // 3.创建Thread类的子类的对象
        MyThread t1 = new MyThread();
        //4.通过此对象调用start()

        t1.start();
        
        // 问题一：不能通过直接调用run()方法启动线程
        // t1.run();
        
        // 问题二：再启动一个线程，遍历100以内的所有偶数. 不可以还让已经start()的线程去执行。会报IllegalThreadException
        // t1.start();
        
        // 我们需要重新创建一个线程的对象
        MyThread t2 = new MyThread();
        t2.start();
        
        
		// 如下操作仍然是在main线程中执行的。
        for (int i = 0; i < 100; i++) {
            if (i%2==0){
                System.out.println(i+"***");
            }
        }
    }
}

 // 创建Thread类的匿名子类的方式
        new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    if (i%2!=0){
                        System.out.println(i);
                    }
                }
            }
        }.start();

Thread 类中常用的方法

1. start(): 启动当前线程；调用当前线程的run()

2. run(): 通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中

3. currentThread(): 静态方法，返回执行当前代码的线程
	
     Thread.currentThread().getName();// 获取当前线程的名
    
4. getName(): 获取当前线程的名字

5. setName(): 设置当前线程的名字
   构造器也可以给线程起名 

6.yield(): 释放的cpu的执行权,但是还有可能再次继续执行
    
7.join();
	thread.join();
    
    在线程a（主线程）中调用线程b（分线程）的join(),此时线程a（主线程）就进入阻塞状态，直到线程b（分线程）完全执行完以后，线程a（主线程）才结束阻塞状态。
        
 8.Stop(): 已过时，当执行此方法时，强制结束

 9.sleep(): 让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内，当前线程是阻塞状态。

 10. isAlive(): 判断当前线程是否还存活

方式二:

创建多线程的方式二：
实现Runnable接口：

	1. 创建一个实现了Runnable接口的类
	
	2. 实现类去实现Runnable中的抽象方法： run();
	
	3. 创建实现类的对象
	
	4. 将此对象作为参数传递到Thread类的构造器类的对象Thread类
        
	5. 通过Thread类的对象调用start()

// 1. 创建一个实现了Runnable接口的类
class MThread implements Runnable{
	// 2. 实现类去实现Runnable中的抽象方法： run();
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i%2==0){
                System.out.println(i);
            }
        }
    }
}


public class ThreadTest1 {
    public static void main(String[] args) {
        //3. 创建实现类的对象
        MThread mThread = new MThread();
		// 4. 将此对象作为参数传递到Thread类的构造器类的对象Thread类
        Thread t1 = new Thread(mThread);
		// 5. 通过Thread类的对象调用start()
        t1.start();

    }
}

方式一和方式二的对比

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

原因：

1. 实现的方式没有单继承的限制
2. 实现的方式更适合来处理多个线程有共享数据的情况

联系：public class Thread impLements Runnable
相同点: 两种方式都需要重写run(),将线程要执行的逻辑声明在run()中。