JAVA_基础多线程（一）

多线程

多线程的建立方式一
1、建立一个继承于Thread类的子类
2、重写Thread类的run() 将此线程执行的操做声明在run()中
3、建立Thread类的子类的对象
4. 经过此对象调用start()

• 启动当前线程
• 调用当前线程的run()
  问题一：咱们不能直接调用run()的方式启动线程。（直接调用，则是在mian()主线程运行的）

public class ThreadDemo {
    public static void main(String[] args) {
        //③建立Thread类的子类的对象
        MyThread1 m1 = new MyThread1();
        MyThread2 m2 = new MyThread2();
        //方法一：④经过此对象调用start()
        m1.start();
        m2.start();
        //方法二：④建立Thread类的匿名子类的方式
        new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {a
                    if (i % 2 == 0) {
                        System.out.println(Thread.currentThread().getName() + ":" + i);
                    }
                }
            }
        }.start();
        new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    if (i % 2 != 0 ) {
                        System.out.println(Thread.currentThread().getName() + ":" + i);
                    }
                }
            }
        }.start();
    }
}
//①建立一个继承于Thread类的子类
class MyThread1 extends Thread {
    //②重写Thread类的run() 将此线程执行的操做声明在run()中
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0 ) {
                System.out.println(Thread.currentThread().getName() + ":" +i);
            }
        }
    }
}
//①建立一个继承于Thread类的子类
class MyThread2 extends Thread {
    //②重写Thread类的run() 将此线程执行的操做声明在run()中
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 != 0 ) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

测试Thread中的经常使用方法

start()：启动当前线程，调用当前线程的run()方法。
run()：一般须要重写Thread类中的此方法，将建立的线程要执行的操做声明在此方法中。
currentThread()：静态方法，返回当前代码的线程。
getName()：获取当前线程的名字。
setName()：设置当前线程的名字。
yield()：释放当前CPU的执行。
join()：在线程A中调用线程B的join()，此时线程A就进入阻塞状态，直到线程B彻底执行完以后，线程A才结束阻塞状态。
stop()：当执行此方法时，强制结束当前线程。（已过期）
sleep()：让当前线程“睡眠”指定的millitime毫秒，在指定的millitime毫秒时间内，当前线程是阻塞状态。
isAlive()：判断当前线程是否存活。

线程的优先级

NORM_PRIORITY = 5;（默认线程级）
MIN_PRIORITY = 1;
MAX_PRIORITY = 10;

如何获取和设置当前线程的优先级
getPriority()：获取当前线程的优先级。
setPriority(int p)：设置当前线程的优先级。

高优先级的线程要抢占低优先级线程CPU的执行权，可是只是从几率上讲，高优先级的线程高几率的状况下被执行。并不意味着只有当高优先级的线程执行完之后，才去执行低优先级。

建立多线程方式二（实现Runnable接口）

① 建立一个实现了Runnable接口的类。
② 实现类去实现Runnable中的抽象方法：run()。
③ 建立实现类的对象。
④ 将此对象做为参数传递到Thread类的构造器中，建立Thread类的对象。
⑤ 经过Thread类的对象调用start()：
第一步：启动线程。
第二步：调用当前线程的run()→调用了Runnable类型的target的run()。

//① 建立一个实现了`Runnable`接口的类
class RThread implements Runnable {

    //② 实现类去实现`Runnable`中的抽象方法：`run()`
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + ":" +i);
        }
    }
}
public class ThreadTest1 {
    public static void main(String[] args) {
        //③ 建立实现类的对象
        RThread rThread = new RThread();

        //④ 将此对象做为参数传递到Thread类的构造器中，建立Thread类的对象
        Thread thread1 = new Thread(rThread);
        thread1.setName("线程一");
        //⑤ 经过Thread类的对象调用start()
        thread1.start();

        //再启动一个线程，遍历100之内的偶数
        Thread thread2 = new Thread(rThread);
        thread2.setName("线程二");
        thread2.start();
    }
}

比较建立线程的两种方式

开发中：优先选择，实现Runnable接口的方式。
缘由:
1.继承的方式有单继承的局限性，而实现的方法没有类的单继承的局限性。
2.实现的方法更适合来处理多个线程有共享数据的状况。

相同点：两中方式都须要重写run()，将线程要执行的逻辑声明在run()中。
联系：public class Thread implements Runnable{}，Thread也是实现Runnable接口，也重写了run()方法。