Java教程（八）多线程

Java多线程

1. 相关概念

1.1 进程(Process)

正在执行的程序。

1.2 线程(Thread)

线程是CPU分配调度的最小单位，是进程的组成部分，一个进程可以存在很多个线程，这些线程共享进程的资源。

2. 多线程的实现

2.1 实现多线程的两种方法

一：继承Thread类，并重写run()方法；
二：普通类实现Runnable

2.2 继承Thread类实现多线程

需要建立三个文件
Task1.java
Task2.java
Window.java

//Task1.java

public class Task1 extends Thread{
    @Override
    public void run() {
        for(int i =1;i<=100000;i++){
            System.out.println("i++++++++++++++"+i);
        }
    }
}

//Task2.java

public class Task2 extends Thread{
    @Override
    public void run() {
        for(int j =1;j<=100000;j++){
            System.out.println("j=============="+j);
        }
    }
}

//Window.java

public class Window {
    public static void main(String[] args) {
        //创建线程1
        Task1 task1 = new Task1();
        //创建线程2
        Task2 task2 = new Task2();

        //运行程序
        task1.start();
        task2.start();
    }
}

如此，便可以看到i和j同时在打印，而且每一次打印的顺序都是不一样的，因为CPU指令每次执行的时候时间调度是不一样的。每台电脑更是不一样的。但Task1和Task2确实是在同时执行的。

2.3 礼让与休眠

线程礼让可以暂停当前线程，让出CPU资源给其他线程。
格式：

Thread.yield();

线程休眠一般用于调试。可以让线程的执行速度变慢。
格式：

 Thread.sleep(1000);//每1000毫秒（也就是1秒）执行一次

注： 线程休眠增加了线程执行的时间，所以可能会发生中断异常，需要捕获异常。
所以一般格式如下：

		try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

2.4 实现Runnable接口实现多线程

//Task3.java

public class Task3 implements Runnable{
    @Override
    public void run() {
        for(int k =1;k<=100000;k++){
            System.out.println("k++++++++++++++"+k);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

//Task4.java

public class Task4 implements Runnable{
    @Override
    public void run() {
        for(int l =1;l<=100000;l++){
            System.out.println("l++++++++++++++"+l);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

//Window.java

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

        Runnable task3 = new Task3();            //由于是继承的Runnable，所以父类引用子类对象
        Runnable task4 = new Task4();


        //运行程序
        Thread thread1 = new Thread(task3);       //引用之后可以传入对象让task3和thread1联系起来
        Thread thread2 = new Thread(task4);
        thread1.start();                          //启动线程只能是Thread里的start()方法
        thread2.start();

        Thread.yield();
    }
}

注： 第一种方法代码更为简洁，但是使用的是继承。由于java只能单继承，所以继承能不用则不用，第二种实际用的多些。

3.线程安全问题

3.1 什么是线程安全问题

当多个线程操作同一共享数据时引发的一种不正常的结果。
演示：
假如有一个售票系统，有三个窗口可以抢票。

// TicketSystem.java
// 火车售票系统

public class TicketSystem implements Runnable{

    static int ticketNum = 200;
    public void run(){
        for(int i=1;i<=1000;i++){
            if(ticketNum>0){
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    System.out.println("操作有误，请重试！");
                }
                ticketNum--;       //减少一张
                System.out.println("恭喜你，成功抢到票！还剩余："+ticketNum+"张票");
            }
        }
    }
}

// Test.java
public class Test {
    public static void main(String[] args) {
        //1.创建一个火车售票系统
        TicketSystem ts = new TicketSystem();
        //2.创建多个线程（多个售票窗口）
        Thread thread1 = new Thread(ts);
        Thread thread2 = new Thread(ts);
        Thread thread3 = new Thread(ts);

        //3.抢票
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

执行后的结果如下：

首先要知道，CPU多线程是同时执行，是一个欺骗的概念，因为还是不同步的。只是间隔非常非常小，对于人的反应来说可以说是同步的，但是程序执行依然是有顺序的。严格意义上来说多线程是多个线程交替执行。

通俗解释： 出现了-1张票的情况，原因是线程中模拟实际情况，一个线程有休眠的时间，而在卖到剩余一张票时，三个窗口同时抢，也就是在第一个窗口休眠时，窗口显示还有一张票时，另外两个窗口已经抢走了。此时第一个窗口再抢，就变成-1张票。这显然是不符合逻辑的。

专业解释： 因为是多个线程同时执行，假如现在只剩余1张票。当第一个线程执行到if语句时，由于CPU调度问题，可能会执行第二个线程，然后第二个线程就会直接执行到最后，此时ticketNum为0，第一个线程再继续执行抢票操作就变成了-1.

3.2 如何解决线程安全问题

上锁。
哪个线程执行哪个线程上锁。
上锁的时候特别考验逻辑。也就是需要判断出哪部分是核心问题。因为上锁会影响效率，锁的代码越多，程序效率越慢。
在上述代码中，如果想避免多个人抢到一张票的情况下，可以给下面这一部分上锁。保证线程在休眠的时候，没有其他线程加入进来。

  if(ticketNum>0){
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    System.out.println("操作有误，请重试！");
                }
                ticketNum--;       //减少一张
                System.out.println("恭喜你，成功抢到票！还剩余："+ticketNum+"张票");
            }

上锁的格式：

synchronized (类名.class){// 类名.class的作用是哪个线程执行，哪个线程上锁（ java 反射 知识）
            			//核心代码
            }

所以上述问题的解决后的代码是：

// TicketSystem.java

public class TicketSystem implements Runnable{

    //武汉---->山海关
    static int ticketNum = 200;
    public void run(){
        for(int i=1;i<=1000;i++){
            synchronized (TicketSystem.class){
                if(ticketNum>0){
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        System.out.println("操作有误，请重试！");
                    }
                    ticketNum--;       //减少一张
                    System.out.println("恭喜你，成功抢到票！还剩余："+ticketNum+"张票");
                }
            }

        }

    }

}

执行后的结果：

完美。