一、使用继承Thread类的方式，完成问题。
问题如下：创建三个窗口卖票，总票数为100张。
package com.atguigu.java;
/**
* 创建三个窗口卖票，总票数为100张。使用继承Thread类的方式。
*
* @anthor shkstart
* @create 2020-03-14-21:20
*/
class Windowtt extends Thread{
private static int ticket = 100;
@Override
public void run() {
while (true){
if (ticket > 0){
System.out.println(Thread.currentThread().getName() + "卖票，票号为：" + ticket);
ticket--;
}else {
break;
}
}
}
}
public class AllTest {
public static void main(String[] args) {
Windowtt wtt1 = new Windowtt();
Windowtt wtt2 = new Windowtt();
Windowtt wtt3 = new Windowtt();
wtt1.setName("窗口一");
wtt2.setName("窗口二");
wtt3.setName("窗口三");
wtt1.start();
wtt2.start();
wtt3.start();
}
}
该方法仍然存在线程安全问题，以后有方法再解决...
二、创建多线程的方式二：实现Runnable接口
实现步骤：
- 1.创建一个实现了Runnable接口的类
- 2.实现类去实现Runnable中的抽象方法：run()
- 3.创建实现类的对象
- 4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
- 5.通过Thread类的对象调用start()
代码演示：
package com.atguigu.java;
/**
* 创建多线程的方式二：实现Runnable接口
* 1.创建一个实现了Runnable接口的类
* 2.实现类去实现Runnable中的抽象方法：run()
* 3.创建实现类的对象
* 4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
* 5.通过Thread类的对象调用start()
*
*
*
* 比较创建线程的两种方式。
* 开发中：优先选择：实现Runnable接口的方式
* 原因：1.实现的方式没有类的单继承性的局限。
* 2.实现的方式更合适来处理多个线程有共享数据的情况。
*
* 联系：public class Thread implements Runnable
* 相同点：两种方式都需要重写run()，将线程要执行的逻辑声明在run()中。
*
*
* @anthor shkstart
* @create 2020-03-14-16:35
*/
//1.创建一个实现了Runnable接口的类
class MTread implements Runnable {//并不继承Thread，直接继承Object
//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.创建实现类的对象
MTread mTread = new MTread();
//4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
Thread T1 = new Thread(mTread);
T1.setName("线程一");
//5.通过Thread类的对象调用start():①启动线程；
// ②调用当前线程的run()-->调用了Runnable类型的target的run()
// 有个大问题：t1是怎么调用到重写的run()。看看thread的源码，run的源码。
T1.start();
//再启动一个线程，遍历100以内的偶数
Thread T2 = new Thread(mTread);
T2.setName("线程二");
T2.start();
}
}
练习题：
创建三个窗口卖票，总票数为100张。使用实现Runnable接口的方式。
package com.atguigu.java;
/**
* 例子：创建三个窗口卖票，总票数为100张。使用实现Runnable接口的方式。
*
* 存在线程安全问题，待解决······
*
* @anthor shkstart
* @create 2020-03-14-17:04
*/
class Window1 implements Runnable{
//不需要改成静态变量，一个对象w只使用一个ticket。
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) {
//只创建了一个对象w
Window1 w = new Window1();
//开启了三个线程，共用这个w，所以票数也共用。
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();
}
}
该方式完成后，也存在一些线程安全问题，日后解决...
四、两种创建线程的比较
- 在开发中，优先选择，实现 Runnable 接口的方式。
- 原因：①实现的方式没有类的单继承性的局限（用第一个实现，变量要改为常量）。②实现的方式更适合来处理多个线程有共享数据的情况。
- 两个方法的联系：public class Thread implements Runnable
- 两种方式都需要重写run()，将线程要执行的逻辑声明在run()中。
