java多线程的创建方式

人之所以痛苦，那是因为你在成长。--------magic_guo
java创建多线程的两种方式：
1.继承Thread类
2.实现Runnable接口

方式一：

/*
* 创建线程的方式一：
* 继承Thread类
* 1.创建一个继承Thread类的子类
* 2.重写run方法
* 3.创建子类对象
* 4.调用Thread类的start()方法：①开启一个线程 ②执行子类重写的run()方法
*
* 线程常用方法：
* 1.start()：开启一个线程，子类重写的run()方法
* 2.run()：重写Thread类的run方法
* 3.currentThread():获取当前线程
* 4.setName():设置当前线程名字
* 5.getName()：获取当前线程名字
* 6.sleep(long time):是进程进入time毫秒的休眠状态
* 7.join()：a.join(b)：线程a进入阻塞状态，直到线程b执行完毕，然后线程a再开始执行
* 8.yield():当前线程释放CPU资源
* 9.stop():一个过时的方法，使当前线程直接死亡
* 10.isAlive():判断的线程是否还存活
*
* MAX_PRIORITY = 10
* NORM_PRIORITY = 5
* MIN_PRIORITY = 1
* setPriority(int newPriority)：设置线程的优先等级
* 线程的优先等级并不意味着等级高的线程先执行完毕才执行优先级低的线程，而是优先级高的线程呗CPU调度的概率增大
* */

// 存在线程安全问题，出现了三个票号为100的票；
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();
        // 另外一种创建线程的方法：匿名线程
//        new Thread(){
//            @Override
//            public void run() {
//                System.out.println("匿名线程");
//            }
//        }.start();
    }
}

// 创建三个窗口，卖100张票
class Window extends Thread{
    // ticket是实例变量，每个对象独有一份，如果不使用static修饰，则为300张票；
    // 使用static修饰，则所有对象共同操作ticket，共100张票；
//    private int ticket = 100;
    private static int ticket = 100;
    @Override
    public void run() {
        while (true){
            if (ticket > 0){
                System.out.println(getName() + " 售票，票号为： " + ticket);
                ticket--;
            }else {
                break;
            }
        }
    }
}

方式二：

/*
*创建线程的方式二：
* 实现Runnable接口
* 1.创建一个实现类，实现Runnable接口
* 2.重写Runnable接口的抽象方法：run()方法
* 3.创建一个实现类的对象，创建一个Thread对象
* 4.将实现类的对象传到Thread中，创建一个Thread对象
* 5.用Thread类的对象调用Thread类的start()方法
*
* 解析：
* 1. Thread类也实现了Runnable接口
* class Thread implements Runnable
* 2. 调用的还是实现类的run方法：此刻使用了多态的形式，将实现类对象传入Thread的run()方法，然后调用了target的run()方法
*     public void run() {
        if (target != null) {
            target.run();
        }
    }
* 3. 在Thread类中将Runnable定义为属性
*     private Runnable target;
* 4. Thread类中，创建了传入Runnable对象的构造器
* public Thread(Runnable target) {
        init(null, target, "Thread-" + nextThreadNum(), 0);
    }
*
*
* 与继承Thread类的方式对比：
* 相同点：
* 1.都调用了Thread类的start()方法
* 2.都调用了子类的重写了run方法
* 不同点：
* 1.继承Thread子类，java的单继承使得子类的功能有局限性，
* 2.实现Runnable接口，接口能够多继承，使得子类的功能得以扩充
* 3.实现Runnable接口，天然的控制了线程对于资源的共享，不必再将资源定义为static
* */

// 但此时仍然存在线程安全问题，出现了三个票号为100的票
public class WindowTest01 {
    public static void main(String[] args) {
        // 虽然ticket为实例变量，每个对象独有一份，但是此时只创建了一个对象，
        // 因此下面三个线程共用ticket，不用再将ticket声明为static
        Window1 w1 = new Window1();
        Thread t1 = new Thread(w1);
        Thread t2 = new Thread(w1);
        Thread t3 = new Thread(w1);

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

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

// 创建三个窗口，卖100张票
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;
            }
        }
    }
}

不到之处，请批评指正，谢谢。