Java多线程之线程的创建和使用（二）

---

一、线程的创建和启动

• Java语言的JVM允许程序运行多个线程，它通过java.lang.Thread类来体现。
• Thread类的特性
  ①每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常把run()方法的主体称为线程体
  ②通过该Thread对象的start()方法来启动这个线程，而非直接调用run()

二、Thread类

• 构造器
  ①Thread()：创建新的Thread对象
  ②Thread(String threadname)：创建线程并指定线程实例名
  ③Thread(Runnable target)：指定创建线程的目标对象，它实现了Runnable接口中的run方法
  ④Thread(Runnable target, String name)：创建新的Thread对象

三、API中创建线程的两种方式

• JDK1.5之前创建新执行线程有两种方法：
  ①继承Thread类的方式
  ②实现Runnable接口的方式
  

1）方式一：继承Thread类

1. 定义子类继承Thread类。
2. 子类中重写Thread类中的run方法。
3. 创建Thread子类对象，即创建了线程对象。
4. 调用线程对象start方法：启动线程，调用run方法。

代码示例

/**
 * 多线程的创建，方式一：继承于Thread类
 * 1.创建一个继承于Thread类的子类
 * 2.重写Thread类的run() --> 将此线程执行的操作声明在run()中
 * 3.创建Thread类的子类的对象
 * 4.通过此对象调用start()
 * <p>
 * 例子：遍历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(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

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

        //4.通过此对象调用start()：①启动当前线程 ②调用当前线程的run()
        t1.start();

        //问题一：我们不能通过直接调用run()的方式启动线程
//        t1.run();

        //问题二：再启动一个线程，遍历100以内的偶数。
        // 不可以还让已经start()的线程去执行。会报IllegalThreadStateException
//        t1.start();

        MyThread t2 = new MyThread();
        t2.start();

        //如下操作仍然是在main线程中执行的
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ":" + i + "---main()---");
            }
        }
    }
}

继承方式的练习

/**
 * 练习：创建两个分线程，其中一个遍历100以内的偶数，另一个线程遍历100以内的奇数。
 */
public class ThreadDemo {
    public static void main(String[] args) {
        //方式一
//        MyTread1 m1 = new MyTread1();
//        MyThread2 m2 = new MyThread2();
//
//        m1.start();
//        m2.start();

        //方式二
        //创建Thread类的匿名子类的方式
        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();

        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();
    }
}

class MyTread1 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

class MyThread2 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 != 0) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

2）方式二：实现Runnable接口

1. 定义子类，实现Runnable接口。
2. 子类中重写Runnable接口中的run方法。
3. 通过Thread类含参构造器创建线程对象。
4. 将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中。
5. 调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法。

代码示例

/**
 * 创建多线程的方式二：实现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(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

public class ThreadTest1 {
    public static void main(String[] args) {
        //3. 创建实现类的对象
        MThread myThread = new MThread();

        //4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread t1 = new Thread(myThread);

        //5. 通过Thread类的对象调用start()：①启动当前线程 ②调用当前线程的run() ---> 调用了Runnable类型的target的run()
        t1.start();

        //再启动一个线程，遍历100以内的偶数
        Thread t2 = new Thread(myThread);
        t2.start();
    }
}

四、创建过程中注意点

• 如果自己手动调用run()方法，那么就只是普通方法，没有启动多线程模式。
• run()方法由JVM调用，什么时候调用，执行的过程控制都有操作系统的CPU调度决定。
• 想要启动多线程，必须调用start方法。
• 一个线程对象只能调用一次start()方法启动，如果重复调用了，则将抛出以上的异常“IllegalThreadStateException”。

五、多窗口卖票

1）继承 Thread 方式

/**
 * 例子：创建三个窗口卖票，总票数为100张，使用继承Thread类的方式
 * <p>
 * 存在线程的安全问题，待解决
 */
class Window extends Thread {
    private static int ticket = 100;

    @Override
    public void run() {
        while (true) {
            if (ticket > 0) {
                System.out.println(getName() + ":卖票，票号为:" + ticket);
                ticket--;
            } else {
                break;
            }
        }
    }
}

public class WindowTest {
    public static void main(String[] args) {
        Window t1 = new Window();
        Window t2 = new Window();
        Window t3 = new Window();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

2）实现 Runnable 方式

/**
 * 例子：创建三个窗口卖票，总票数为100张，使用实现Runnable接口的方式
 * <p>
 * 存在线程的安全问题，待解决
 */
class Window1 implements Runnable {
    private int ticket = 100;

    @Override
    public void run() {
        while (true) {
            if (ticket > 0) {
                System.out.println(Thread.currentThread().getName() + ":卖票，票号为:" + ticket);
                ticket--;
            } else {
                break;
            }
        }
    }
}

public class WindowTest1 {
    public static void main(String[] args) {
        Window1 w = new Window1();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

六、继承方式和实现方式的联系与区别

public class Thread extends Object implements Runnable

• 区别
  ①继承Thread：线程代码存放Thread子类run方法中。
  ②实现Runnable：线程代码存在接口的子类的run方法。
• 实现方式的好处
  ①避免了单继承的局限性。
  ②多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源。

 * 比较创建线程的两种方式
 * 开发中，优先选择实现Runnable接口的方式
 * 原因：
 * 1. 实现的方式没有类的单继承性的局限性
 * 2. 实现的方式更适合来处理多个线程有共享数据的情况
 * <p>
 * 联系：public class Thread implements Runnable
 * 相同点：两种方式都需要重写run(),将线程要执行的逻辑声明在run()中

七、线程的常用方法

• void start(): 启动线程，并执行对象的run()方法。
• run(): 线程在被调度时执行的操作。通常需要重写Thread类中的此方法，将创建的线程执行的操作声明在此方法中。
• String getName(): 获取当前线程的名字。
• void setName(String name):设置当前线程的名字。
• static Thread currentThread(): 返回当前线程。在Thread子类中就是this，通常用于主线程和Runnable实现类。
• static void yield()：线程让步，释放当前cpu的执行权。
  ①暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程
  ②若队列中没有同优先级的线程，忽略此方法。
• join() ：当某个程序执行流中调用其他线程的 join() 方法时，调用线程将被阻塞，直到 join() 方法加入的 join 线程执行完为止。
  ①低优先级的线程也可以获得执行。
• static void sleep(long millis)：让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内，当前线程是阻塞状态。
  ①令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后重排队。
  ②抛出InterruptedException异常。
• stop(): 强制线程生命期结束，不推荐使用。
• boolean isAlive()：返回boolean，判断当前线程是否存活。

八、线程的调度

• 调度策略
  ①时间片
  ②抢占式：高优先级的线程抢占CPU。
• Java的调度方法
  ①同优先级线程组成先进先出队列（先到先服务），使用时间片策略。
  ②对高优先级，使用优先调度的抢占式策略。

九、线程优先级的设置

• 线程的优先级等级
  ①MAX_PRIORITY：10
  ②MIN _PRIORITY：1
  ③NORM_PRIORITY：5 （默认优先级）
• 如何获取和设置当前线程的优先级
  ①getPriority() ：获取线程的优先级。
  ②setPriority(int newPriority) ：获取线程的优先级。
• 说明
  ①线程创建时继承父线程的优先级。
  ②低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用。

高优先级的线程要抢占低优先级线程cpu的执行权。但是只是从概率上讲，高优先级的线程高概率情况下被执行。
因此，并不意味着只有当高优先级的线程执行完以后，低优先级的线程才执行。