Java 多线程线程的线程不安全问题 -- 创建多线程的两种方式

1. 前言：

该系列文章梳理关于Java多线程的一些知识
Java 创建多线程有四种方式：
（1）. 继承Thread
（2）. 实现Runnable 接口
（3）. 实现 Callable 接口
（4）. 线程池
本系列前三篇文章主要针对前两种总结（避免文章太长）

2.继承Thread 创建多线程（线程不安全）

步骤：

1. 创建一个继承于Thread类的子类
2. 重写Thread类的run() -->
   将此线程执行的操作声明在run()中
3. 创建Thread类的子类的对象
4. 通过此对象调用start()

代码举例：

/**
 * 通过 继承（Thread） 创建多线程售票问题，此时是线程不安全
 * window 3 是通过 同步方法，对 window1 进行改进
 * @author JL
 * @create 2022-04-24 14:40
 */
class window1 extends Thread {

    private int ticket = 100;
    @Override
    public void run() {
        while (true) {
            if (ticket > 0) {
//                    try { // 睡眠，让代码有更大机会异常
//                        Thread.sleep(100);
//                    } catch (InterruptedException e) {
//                        e.printStackTrace();
//                    }

                System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
                ticket--;
            } else {
                break;
            }
        }
    }
}

public class window1Test {
    public static void main(String[] args) {

        window1Test win = new window1Test();
        window1 w1 = new window1();
        window1 w2 = new window1();
        window1 w3 = new window1();

        w1.setName("窗口一");
        w2.setName("窗口二");
        w3.setName("窗口三");

        w1.start();
        w2.start();
        w3.start();

    }
}

3. 通过 实现 Runnable 创建（线程不安全）

步骤：

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

代码举例

/**
 * 通过 runnable 实现多线程售票问题，此时也是线程不安全
 *
 * @author JL
 * @create 2022-04-24 15:12
 */
class window2 implements Runnable{


        private int ticket = 100;
        @Override
        public void run() {
            while (true) {
                if (ticket > 0) {
//                    try { // 睡眠，让代码有更大机会异常
//                        Thread.sleep(100);
//                    } catch (InterruptedException e) {
//                        e.printStackTrace();
//                    }

                    System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }

public class window2Test {
    public static void main(String[] args) {
        window2Test window = new window2Test();

        window2 win = new window2();

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

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

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

4.总结

本文总结了前两种Java实现多线程的方式，但是此时是线程不安全的，后续文章梳理如何改进。
改进包括 ：
1. lock 锁
通过lock解决Java多线程的不安全问题
3. synchronized 代码块
4. synchornized 方法