Java多线程

Java 多线程

导学:
①、基本概念: 程序、进程、线程
②、线程的创建和使用
③、线程的生命周期
④、线程的同步
⑤、线程的通信
⑥、JDK5.0新增线程创建方式

1、基本概念: 程序、进程、线程

基本概念:

> 程序: 为完成特定的任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。
	   【干什么的(完成任务的)？怎么干的(写代码实现的)？最后是什么？(写完了代码，底层即是0&1指令的集合)】
	   
> 进程: 程序的一次执行过程，或者一个正在运行的程序。是一个动态的过程:有它自身的产生、存在、消亡的过程。（生命周期）
		例如: 运行中的QQ，运行中的MP3播放器 程序是静态的，进程是动态的。

> 线程: 进程可以细化为线程，是一个程序内部的一条执行路径。
		>> 若一个进程同一时间并行执行多个线程，就是支持多线程的。
		>> 线程是调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc),线程切换的开销小。
		>> 一个进程中的多个线程共享相同的内存单元/内存地址空间 ==》 它们从同一堆中分配对象，可以访问相同的变量和对象。
		   这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。

1.1、进程和线程

图解：

①、 单核CPU和多核CPU的理解:
	> 单核CPU，其实是一种假的多线程，因为在一个时间单元内，也只能执行一个线程的任务。
	  例如：虽然有多车道，但是收费站只有一个工作人员在收费，只有收了费才能通过，那么
	  CPU就好比收费人员。如果有某个人不想交钱，那么收费人员可以把他“挂起”（晾着他，
	  等他想通了，准备好了钱，再去收费）。但是因为CPU时间单元特别短，因此感觉不出来。

	> 如果是多核的话，才能更好的发挥多线程的效率。（现在的服务器都是多核的）。

	> 一个Java应用程序java.exe，其实至少有三个线程：main()主线程，gc()垃圾回收线程，
	  异常处理线程。当然如果发生异常，会影响主线程。
  	 
 

②、并行与并发:
   并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。
   并发：一个CPU(采用时间片)同时执行多个任务。比如：秒杀、多个人做同一件事。

1.2、使用多线程的优点

》背景:
  以单核CPU为例，只使用单个线程先后完成多个任务（调用多个方法）,
  肯定比用多个线程来完成用的时间更短，为何仍需多线程呢？
  
》多线程的优点:
  1)、提高应用程序的响应。对图形化界面更有意义，可增强用户体验。
  2)、提高计算机系统CPU的利用率。
  3)、改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改。

1.3、何时使用多线程

何时使用多线程:
> 程序需要同时执行两个或多个任务。
> 程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。
> 需要一些后台运行的程序时。

2、线程的创建和使用

2.1、线程的创建和启动

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

2.2、Thread类的构造器

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

2.3、API中创建线程的两种方式（jdk1.5之前）

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

2.3.1、创建多线程的方式之一：继承Thread类

代码演示：

package com.rucoding.java;

/**
 * @author LiuYiXin
 * 继承Thread方式的步骤：
 * 第一步：创建一个继承于Thread类的子类
 * 第二步：重写Thread的run()方法
 * 第三步：创建Thread类的子对象
 * 第四步：通过此对象调用start()
 */
public class MyThreadTest {
    public static void main(String[] args) {
        //第三步，创建子类的对象
        MyThread mt = new MyThread();
        //第四步，启动线程
        mt.start();  //start()方法的作用: ①.启动当前的线程 ②.调用当前线程的run()方法

        //演示主线程main
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println("main主线程：" + i);
            }
        }

    }
}

//第一步，创建子类继承于Thread类
class MyThread extends Thread {
    //第二步，重写run()方法

    @Override
    public void run() {
        //业务代码，实现逻辑，输出100以内的偶数
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println("子线程：" + i);
            }
        }
    }
}

图解：

mt子线程的创建和启动过程：

2.3.2、创建过程中的两个问题说明

问题描述：
①.问题1:我们不能通过直接调用run()的方式启动线程。(线程未启动/重写方法的调用).
②.问题二:再启动一个线程，遍历100以内的偶数.不可以还让已经start()的线程去执行。报错 IllegalThreadStateException.

代码描述：

package com.rucoding.java;

/**
 * @author LiuYiXin
 * 继承Thread方式的步骤：
 * 第一步：创建一个继承于Thread类的子类
 * 第二步：重写Thread的run()方法
 * 第三步：创建Thread类的子对象
 * 第四步：通过此对象调用start()
 */
public class MyThreadTest {
    public static void main(String[] args) {
        //第三步，创建子类的对象
        MyThread mt = new MyThread();
        //第四步，启动线程
        mt.start();  //start()方法的作用: ①.启动当前的线程 ②.调用当前线程的run()方法

        //问题1:我们不能通过直接调用run()的方式启动线程。
//        mt.run();

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

        //演示主线程main
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println("main主线程：" + i);
            }
        }

    }
}

//第一步，创建子类继承于Thread类
class MyThread extends Thread {
    //第二步：重写run()方法

    @Override
    public void run() {
        //业务代码，实现逻辑，输出100以内的偶数
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println("子线程：" + i);
            }
        }
    }
}

小结

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

2.3.3、练习1

练习:创建两个分线程，其中一个遍历100以内的偶数，另一个遍历100以内的奇数。

代码演示：

package com.rucoding.exer;

/**
 * @author LiuYiXin
 * 练习:创建两个分线程，其中一个遍历100以内的偶数，另一个遍历100以内的奇数
 */
public class ThreadDemo {
    public static void main(String[] args) {
        //第三步，创建子类对象
        EvenThread evenThread = new EvenThread();
        OddThread oddThread = new OddThread();

        //设置线程名称
        evenThread.setName("偶数线程:");
        oddThread.setName("奇数线程:");
        //第四步，启动线程
        evenThread.start();
        oddThread.start();

    }
}
//第一步，创建线程
class EvenThread extends Thread{
    //第二步，重写方法

    @Override
    public void run() {
        //逻辑实现 偶数输出
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(getName()  + " " + i);
            }
        }
    }
}

//第一步，创建线程
class OddThread extends Thread{
    //第二步，重写方法

    @Override
    public void run() {
        //逻辑实现 奇数输出
        for (int i = 0; i < 100; i++) {
            if(i % 2 != 0){
                System.out.println(getName()  + " " + i);
            }
        }
    }
}

改造写法：(匿名子类的方式)

package com.rucoding.exer;

/**
 * @author LiuYiXin
 */
public class AnonymousThreadDemo {
    public static void main(String[] args) {

        //创建Thread的匿名子类
        new Thread("偶数线程: ") {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    if (i % 2 == 0) {
                        System.out.println(getName() + " " + i);
                    }
                }
            }
        }.start();

        //创建Thread类的匿名子类的方式
        new Thread("奇数线程: ") {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    if (i % 2 != 0) {
                        System.out.println(getName() + " " + i);
                    }
                }
            }
        }.start();

    }
}

2.3.4、Thread类的有关方法

Thread类的常用方法:
> start():启动当前线程，执行当前线程的run().
> run():通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中.
> currentThread(): 静态方法，返回当前代码执行的线程.
> getName():获取当前线程的名字.
> setName():设置当前线程的名字.
> yield():释放当前CPU的执行权.
> join():在线程a中调用线程b的join(),此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态。
> stop():已过时。当执行此方法时，强制结束当前线程。
> sleep(long millitime)：让当前线程“睡眠”指定时间的millitime毫秒)。在指定的millitime毫秒时间内，当前线程是阻塞状态的。
> isAlive()：返回boolean，判断线程是否还活着。

代码演示：

package com.rucoding.java;

/**
 * @author LiuYiXin
 */
public class ThreadMethodDemo {
    public static void main(String[] args) {
        //
        HelloThread ht = new HelloThread();
        //
//        ht.setName("分线程:");
        ht.start();  //1.start()方法 : 启动当前线程；执行当前线程的run()方法

        //main主线程
        //5.setName() 设置当前线程的名字
        Thread.currentThread().setName("主线程");

        for (int i = 0; i < 100; i++) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }

            if (i == 20) {
                try {
                    //7.join()方法  在主线程mian调用ht线程的join()方法，此时主线程main就进入
                    //阻塞状态，直到线程ht完全执行完以后，主线程main才结束阻塞状态。
                    ht.join();
//                    ht.stop();//stop方法 已过时  强制结束当前的线程
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }

        //10.返回boolean类型，判断线程是否还活着。
        System.out.println(ht.isAlive());

    }
}

//
class HelloThread extends Thread {
    @Override
    public void run() {  //2.run()方法 重写该方法 将创建的线程要执行的操作声明在此方法中
        for (int i = 0; i < 100; i++) {

            //当前线程进入睡眠时
            try {
                //9.sleep()方法  让当前的线程 “睡眠” 指定时间的millis(毫秒)。
                //指定的millis毫秒内，结束阻塞状态
                sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            if (i % 2 == 0) {
                //3.currentThread()静态方法 ，返回当前代码运行的线程
                //4.getName()方法  获取当前线程的名字
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }

            if (i == 20) {
                yield();  //6.yield() 让步 释放当前的cpu执行权
            }

        }
    }
}

2.3.5、线程的调度

①.调度策略：

​ 时间片：

②.Java的调度方法

>> 同优先级线程组成先进先出队列（先到先服务），使用时间片策略.
>> 对高优先级，使用优先调度的抢占式策略.

2.3.6、线程的优先级

线程的优先级:
  >> MAX_PRIORITY: MAX_PRIORITY = 10;  //最大值
  >> MIN_PRIORITY: MIN_PRIORITY = 1;  //最小值
  >> NORM_PRIORITY: NORM_PRIORITY = 5; //默认值

代码演示：

package com.rucoding.java;

/**
 * @author LiuYiXin
 */
public class ThreadPriorityDemo {
    public static void main(String[] args) {
        //创建线程对象
        PriorityThread pt = new PriorityThread();
        //设置线程名称
        pt.setName("线程 ");
        //启动线程
        pt.start();


        //主线程main
        Thread.currentThread().setName("主线程: ");  //设置名称
        //默认的优先级：NORM_PRIORITY 5
//        Thread.currentThread().setPriority(10); //设置优先级
        Thread.currentThread().setPriority(Thread.MAX_PRIORITY); //设置优先级 MAX_PRIORITY 为10
        Thread.currentThread().setPriority(Thread.MIN_PRIORITY); //设置优先级 MIN_PRIORITY 为1
        for (int i = 0; i < 100; i++) {
            if (i % 2 != 0) {
                System.out.println(Thread.currentThread().getName() + Thread.currentThread().getPriority() + ":" + i);
            }
        }
    }
}

//创建继承于Thread类的子类
class PriorityThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + " " + getPriority() + ":" + i);
            }
        }
    }
}

2.3.7、练习2

练习: 模拟创建三个窗口，总票数为100张。
//存在线程安全问题，待解决

package com.rucoding.exer;

/**
 * @author LiuYiXin
 */
public class WindowThreadDemo {
    public static void main(String[] args) {
        //创建对象
        Window wt1 = new Window();
        Window wt2 = new Window();
        Window wt3 = new Window();
        //设置名称
        wt1.setName("窗口1");
        wt2.setName("窗口2");
        wt3.setName("窗口3");
        //启动线程
        wt1.start();
        wt2.start();
        wt3.start();

    }
}

//创建售票窗口类
class Window extends Thread {
    //重写方法
    private static int ticket = 100;

    @Override
    public void run() {
        while (true) {
            if (ticket > 0) { //可能某一瞬间， 三个线程同时通过if判断
                System.out.println(Thread.currentThread().getName() + "售票，票号为: " + ticket);
                ticket--;
            } else {
                break;
            }
        }
    }
}

2.3.8、创建多线程的方式之二：实现Runnable接口

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

代码演示：

package com.rucoding.java;

/**
 * @author LiuYiXin
 */
public class RunnableDemo {
    public static void main(String[] args) {
        //创建实现类对象
        MyThreadByImp myThreadByImp = new MyThreadByImp();
        //创建Thread对象，通过构造器传参
        Thread t = new Thread(myThreadByImp); // Runnable target = new MyThreadByImp();
        //设置线程名称
        t.setName("线程1");
        //启动线程
        t.start();

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

    }
}


//创建实现Runnable接口的类
class MyThreadByImp implements Runnable {
    //重写方法
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

2.3.9、创建线程_继承方式和实现方式的联系与区别

比较创建线程的两种方式:
> 实际开发中， 优先选择实现Runnable接口的
	原因: ①.实现的方式没有类的单继承性的限制.
		 ②.实现的方式更适合来处理多个线程有共享数据的情况。

> 联系: public class Thread implements Runnable {} //Thread类也实现了Runnable接口

> 相同点: 两种方式都需要重写run()方法,将线程要执行的逻辑声明在run()中。

2.4、线程的分类

☆> Java中的线程分为两类: 一种是守护进程，一种是用户线程。
>> 它们在几乎每个方面都是相同的，唯一的区别是判断JVM何时离开。
>> 守护线程是用来服务用户线程的，通过在start()方法前调用thread.setDaemon(true)
	可以把一个用户线程变成一个守护线程。
>> Java垃圾回收就是一个典型的守护线程。
>> 若JVM中都是守护线程，当前JVM将退出。
>> 形象理解：兔死狗烹，鸟尽弓藏

3、线程的生命周期

>> JDK中用Thread.State类定义了线程的几种状态:
	要想实现多线程，必须在主线程中创建新的线程对象。Java语言使用Thread类及其子类的对象来表示线程，
	在它的一个完整的生命周期中通常要经历如下的五种状态:
>>> 新建：当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
>>> 就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源
>>> 运行：当就绪的线程被调度并获得CPU资源时,便进入运行状态，run()方法定义了线程的操作和功能
>>> 阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出CPU并临时中止自己的执行，进入阻塞状态
>>> 死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束

线程的生命周期图示：

4、线程的同步

1)、问题提出:
>> 多个线程执行的不确定性引起执行结果的不稳定
>> 多个线程对账本的共享，会造成操作的不完整性，会破坏数据。

例如：

2)、例题：模拟火车站售票程序，开启三个窗口售票。（实现Runnable接口的方式）

代码演示：

package com.rucoding.exer;

/**
 * @author LiuYiXin
 */
public class WindowRunnableDemo {
    public static void main(String[] args) {
        //创建实现类对象
        WindowByImp w = new WindowByImp();
        //创建线程，构造器接受传参对象
        Thread t1 = new Thread(w); //Runnable target = new WindowByImp()
        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();
    }
}

//创建售票窗口类
class WindowByImp implements Runnable {
    private int ticket = 100;

    //重写run()方法
    @Override
    public void run() {
        //业务逻辑实现
        while (true) {
            if (ticket > 0) {
                System.out.println(Thread.currentThread().getName() + "售票了，票号为: " + ticket);
                ticket--;
            } else {
                break;
            }
        }
    }
}

问题分析：针对上述代码的
>>> 理想状态下:

>>> 极端状态下:

4.1、同步代码块_处理实现Runnable接口方式的线程安全问题

场景还原: 上述代码例子，创建三个窗口售票，总票数为100张，使用实现Runnable接口的方式
	1). 售票过程中出现重票、错票 ===》 出现了线程的安全问题。
	2). 问题出现的原因分析: 当某个线程操作车票的过程中，尚未完成操作时，其他线程参与进来，也操作车票。
	3). 如何解决: 当一个线程a在操作ticket的时候，其他线程不允许进来，不能参与，直到线程a操作完ticket时，
     	其他线程才可以操作ticket。这种情况即使线程a出现了阻塞，也不能改变。
	4). 在java中，我们可通过 同步机制，来解决线程的安全问题。
	    >>> 方式一: 同步代码块
	    	synchronized(同步监视器)
	    	{
	    	 //需要被同步的代码
	    	}
	    说明: 1).操作共享数据的代码，即为需要被同步的代码 --->不能包含代码多了，也不能包含代码少了。
	    	 2).共享数据：多个线程共同操作的变量。比如：ticket就是共享数据。
	    	 3).同步监视器，俗称：锁。任何一个类的对象，都可以来充当锁。[要求：多个线程必须要共用同一把锁]
	    补充: 在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。 (实现的方式只创建一个对象)
	    
	    >>> 方式二: 同步方法
	    	 如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的。
	    	 
	 5).同步的方式，解决了线程的安全问题  ---好处
	    操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。---局限性

代码演示：

package com.rucoding.exer;

/**
 * @author LiuYiXin
 */
public class WindowRunnableDemoSynchronized {
    public static void main(String[] args) {
        //创建实现类对象
        WindowByImpSync w = new WindowByImpSync();
        //创建线程，构造器接受传参对象
        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();
    }
}

//创建售票窗口类
class WindowByImpSync implements Runnable {
    private int ticket = 100;
    Block block = new Block();
    Object obj = new Object();

    //重写run()方法
    @Override
    public void run() {
        //业务逻辑实现
        while (true) {
//            synchronized (block) { //加锁 任何对象都可以，前提是多个线程必须共用同一个锁对象
//            synchronized (obj) { //加锁 任何对象都可以，前提是多个线程必须共用同一个锁对象
                synchronized (this) {  //this 表示当前对象，唯一的window对象
                if (ticket > 0) {

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

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

class Block{

}

分析同步原理：

4.2、同步代码块_处理继承Thread类的线程安全问题

代码演示：

package com.rucoding.exer;

/**
 * @author LiuYiXin
 */
public class WindowThreadDemoSynchronized {
    public static void main(String[] args) {
        //创建对象
        WindowByThreadSync wt1 = new WindowByThreadSync();
        WindowByThreadSync wt2 = new WindowByThreadSync();
        WindowByThreadSync wt3 = new WindowByThreadSync();
        //设置名称
        wt1.setName("窗口1");
        wt2.setName("窗口2");
        wt3.setName("窗口3");
        //启动线程
        wt1.start();
        wt2.start();
        wt3.start();

    }
}

//创建售票窗口类
class WindowByThreadSync extends Thread {
    //重写方法
    private static int ticket = 100;
    private static Object obj = new Object(); //加static静态修饰，只有唯一一份

    @Override
    public void run() {
        while (true) {
//            synchronized (this) { //错误 this 表示当前对象，继承方式是创建三个对象了，不是同一把锁，
//            synchronized (obj) { //正确
            synchronized (WindowByThreadSync.class) { //Class clazz = Windows.class 类也是对象
                if (ticket > 0) {
                    try {
                        sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "售票，票号为: " + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

4.3、同步方法_处理实现Runnable的线程安全问题

代码演示：

package com.rucoding.exer;

/**
 * @author LiuYiXin
 */
public class WindowRunnableSyncMethodDemo {
    public static void main(String[] args) {
        //创建实现类对象
        WindowByImp2 w = new WindowByImp2();
        //创建线程，构造器接受传参对象
        Thread t1 = new Thread(w); //Runnable target = new WindowByImp()
        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();
    }
}

//创建售票窗口类
class WindowByImp2 implements Runnable {
    private int ticket = 100;

    //重写run()方法
    @Override
    public void run() {
        while (true) {
            if (ticket > 0) {
                showInfo();
            } else {
                break;
            }
        }
    }

    public synchronized void showInfo() { //同步监视器 this
        //业务逻辑实现
        if (ticket > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "售票了，票号为: " + ticket);
            ticket--;
        }

    }

}

4.4、同步方法_处理继承Thread类的线程安全问题

代码演示：

package com.rucoding.exer;

/**
 * @author LiuYiXin
 */
public class WindowThreadSyncMethodDemo {
    public static void main(String[] args) {
        //创建对象
        Window2 wt1 = new Window2();
        Window2 wt2 = new Window2();
        Window2 wt3 = new Window2();
        //设置名称
        wt1.setName("窗口1");
        wt2.setName("窗口2");
        wt3.setName("窗口3");
        //启动线程
        wt1.start();
        wt2.start();
        wt3.start();

    }
}

//创建售票窗口类
class Window2 extends Thread {
    //重写方法
    private static int ticket = 100;

    @Override
    public void run() {
        while (true) {
            if (ticket > 0) {
                showInfo();
            } else {
                break;
            }
        }
    }

    //    public synchronized void showInfo() { // 错误 同步监视器：t1,t2,t3。此种解决方式是错误的
    public static synchronized void showInfo() { //同步监视器 类.class Window2.class
        //业务逻辑实现
        if (ticket > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "售票了，票号为: " + ticket);
            ticket--;
        }

    }


}

4.5、线程安全的单例模式之懒汉式

之前章节【面向对象编程（下）】1.6、单例设计模式（Singleton） 编写懒汉式代码，有安全问题待解决，如下代码已解决：

代码演示：

package com.rucoding.exer;

/**
 * @author LiuYiXin
 */
public class SingleByLazySync {

}

class SingleClass {

    //懒汉式的单例模式
    private SingleClass() {
    }

    //
    private static SingleClass instance = null;

    //
    public static SingleClass getInstance() {
        //方式一：效率偏差
//        synchronized (SingleClass.class) {
//            if (instance == null) {
//                instance = new SingleClass();
//            }
//            return instance;
//        }

        //先判断一下  效率稍高
        if (instance == null) {
            synchronized (SingleClass.class) {
                if (instance == null) {
                    instance = new SingleClass();
                }
            }
        }
        return instance;

    }
}

4.6、死锁问题

>> 死锁:
	不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁.
	出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续.
>> 解决方法:
	>>> 专门的算法、原则
	>>> 尽量减少同步资源的定义
	>>> 尽量避免嵌套同步

代码演示：

package com.rucoding.java;

/**
 * @author LiuYiXin
 */
public class DeadLockDemo {
    public static void main(String[] args) {
        StringBuffer s1 = new StringBuffer(); //后面常用类会提到
        StringBuffer s2 = new StringBuffer();

        //
        new Thread() {
            @Override
            public void run() {
                synchronized (s1) {
                    s1.append("a");
                    s2.append("1");

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

                    synchronized (s2) {
                        s1.append("b");
                        s2.append("2");
                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }

            }
        }.start();


        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (s2) {
                    s1.append("c");
                    s2.append("3");

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


                    synchronized (s1) {
                        s1.append("d");
                        s2.append("4");
                        System.out.println(s1);
                        System.out.println(s2);
                    }

                }
            }
        }).start();


    }
}

代码演示2：

package com.rucoding.java;

/**
 * @author LiuYiXin
 */
class A {
    public synchronized void foo(B b) {
        System.out.println("当前线程名: " + Thread.currentThread().getName()
                + " 进入了A实例的foo方法"); // ①
        try {
            Thread.sleep(200);
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }
        System.out.println("当前线程名: " + Thread.currentThread().getName()
                + " 企图调用B实例的last方法"); // ③
        b.last();
    }

    public synchronized void last() {
        System.out.println("进入了A类的last方法内部");
    }
}

class B {
    public synchronized void bar(A a) {
        System.out.println("当前线程名: " + Thread.currentThread().getName()
                + " 进入了B实例的bar方法"); // ②
        try {
            Thread.sleep(200);
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }
        System.out.println("当前线程名: " + Thread.currentThread().getName()
                + " 企图调用A实例的last方法"); // ④
        a.last();
    }

    public synchronized void last() {
        System.out.println("进入了B类的last方法内部");
    }
}

public class DeadLock implements Runnable {
    A a = new A();
    B b = new B();

    public void init() {
        Thread.currentThread().setName("主线程");
        // 调用a对象的foo方法
        a.foo(b);
        System.out.println("进入了主线程之后");
    }

    public void run() {
        Thread.currentThread().setName("副线程");
        // 调用b对象的bar方法
        b.bar(a);
        System.out.println("进入了副线程之后");
    }

    public static void main(String[] args) {
        DeadLock dl = new DeadLock();
        new Thread(dl).start();
        dl.init();
    }
}

4.7、Lock锁方式解决线程安全问题

>>> 从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。
>>> java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，
    每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
>>> ReentrantLock类实现了Lock ，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，
	比较常用的是ReentrantLock，可以显式加锁、释放锁。

>>> 引申面试题:
    synchronized 与 Lock的异同？
    
    相同：二者都可以解决线程安全问题
    不同：synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器.
         Lock需要手动的启动同步（lock()），同时结束同步也需要手动的实现（unlock()）.
         Lock是显式锁（手动开启和关闭锁，别忘记关闭锁），
         synchronized是隐式锁，出了作用域自动释放。
         Lock只有代码块锁，synchronized有代码块锁和方法锁。
         使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）

>>> 优先使用顺序：
    Lock ---> 同步代码块（已经进入了方法体，分配了相应资源）---> 同步方法（在方法体之外）
    

代码演示：

package com.rucoding.java;

import java.util.concurrent.locks.ReentrantLock;

/**
 * @author LiuYiXin
 */
public class WindowRunnableDemo {
    public static void main(String[] args) {
        //创建实现类对象
        WindowByImp w = new WindowByImp();
        //创建线程，构造器接受传参对象
        Thread t1 = new Thread(w); //Runnable target = new WindowByImp()
        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();
    }
}

//创建售票窗口类
class WindowByImp implements Runnable {
    private int ticket = 100;
    //Lock接口实现类的创建
    private ReentrantLock lock = new ReentrantLock();

    //重写run()方法
    @Override
    public void run() {
        //业务逻辑实现
        while (true) {
            try {

                //调用锁定方法lock方法
                lock.lock();

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

                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "售票了，票号为: " + ticket);
                    ticket--;
                } else {
                    break;
                }
            } finally {  //注意：如果同步代码有异常，要将unlock()写入finally语句块
                //调用解锁方法unlock
                lock.unlock();
            }
        }
    }
}

5、线程的通信

线程通信的例子：使用两个线程打印1-100。线程1, 线程2 交替打印!

涉及到方法:
>> wait()方法，一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
>> notify()方法，一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的那个。
>> notifyAll()方法，一旦执行此方法，就会唤醒所有被wait的线程。

说明:
>> wait()/notify()/notifyAll() 三个方法必须使用在同步代码块或同步方法中。
>> wait()/notify()/notifyAll() 三个方法的调用者必须是同步代码块或同步方法中的同步监视器。
>> wait()/notify()/notifyAll() 三个方法是定义在java.lang.Object类中。

代码演示：

package com.rucoding.java;

/**
 * @author LiuYiXin
 * 线程通信的例子：使用两个线程打印1-100。线程1, 线程2 交替打印
 */
public class ThreadCommunicationDemo {
    public static void main(String[] args) {
        Number number = new Number();
        Thread t1 = new Thread(number);
        Thread t2 = new Thread(number);
        //设置线程名字
        t1.setName("线程1");
        t2.setName("线程2");
        //启动线程
        t1.start();
        t2.start();

    }
}

//创建实现Runnable接口的类
class Number implements Runnable {

    private int num = 1;
    private Object obj = new Object();

    @Override
    public void run() {
        while (true) {
            synchronized (obj) {

                //唤醒被wait的一个线程
                obj.notify();

                if (num <= 100) {

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

                    System.out.println(Thread.currentThread().getName() + "打印数字为：" + num);
                    num++;

                    //当前线程就进入阻塞状态，并释放同步监视器。
                    try {
                        obj.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                } else {
                    break;
                }
            }
        }


    }
}

5.1、sleep()和wait()的区别(面试题)

面试题：sleep() 和 wait()的异同？
>> 相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态。
>> 不同点：
		1）两个方法声明的位置不同：Thread类中声明sleep() , Object类中声明wait()
		2）调用的要求不同：sleep()可以在任何需要的场景下调用。 wait()必须使用在同步代码块或同步方法中
		3）关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁。

5.2、经典例题：生产者/消费者问题

>> 生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处
    取走产品，店员一次只能持有固定数量的产品(比如:20），如果生产者试图
    生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通
    知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如
    果店中有产品了再通知消费者来取走产品。

>> 这里可能出现两个问题:
	>>> 生产者比消费者快时，消费者会漏掉一些数据没有取到。
	>>> 消费者比生产者快时，消费者会取相同的数据。
	
>> 分析：
	>>> 是否是多线程的问题？是，生产者的线程，消费者的线程
	>>> 是否有共享数据的问题？是，店员、产品、产品数
	>>> 如何解决线程的安全问题？同步机制，有三种方法
	>>> 是否涉及线程的通信？是

代码演示：

package com.rucoding.exer;

/**
 * @author LiuYiXin
 */
public class ProductDemo {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();
        Productor p1 = new Productor(clerk);
        p1.setName("生产者1");

        Consumer c1 = new Consumer(clerk);
        Consumer c2 = new Consumer(clerk);
        Consumer c3 = new Consumer(clerk);
        c1.setName("消费者1");
        c2.setName("消费者2");
        c3.setName("消费者3");

        //
        p1.start();
        c1.start();

    }
}
//店员
class Clerk{

    //初始化产品数量
    private int productCount = 0;

    //生产产品
    public synchronized void produceProduct() {
        if(productCount < 20){
            productCount++;
            System.out.println(Thread.currentThread().getName() + ": 开始生产第" + productCount + "个产品");
            //
            notify();
        }else{
            //超出了，等待
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    //消费产品
    public synchronized void consumeProduct() {
        if(productCount > 0){
            System.out.println(Thread.currentThread().getName() + ":开始消费第" + productCount + "个产品");
            productCount--;

            //
            notify();
        }else{
            //没有产品，等待
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

//生产者
class Productor extends Thread{
    private Clerk clerk;
    public Productor(Clerk clerk){
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println(getName() + ": 开始生产产品......");

        while(true){

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

            clerk.produceProduct();
        }

    }
}

//消费者
class Consumer extends Thread{
    private Clerk clerk;
    public Consumer(Clerk clerk){
       this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println(getName() + ": 开始消费产品......");
        while(true){
            try {
                sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.consumeProduct();
        }
    }
}

6、JDK5.0新增线程创建方式

6.1、创建多线程的方式之三：实现Callable接口

实现Callable接口:
1)、创建一个实现Callable的实现类
2)、实现call方法，将此线程需要执行的操作声明在call()中
3)、创建Callable接口实现类的对象
4)、将此Callable接口实现类的对象传递到FutureTask构造器中，创建FutureTask的对象
5)、将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
6)、获取Callable中call方法的返回值:
    get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。

代码演示：

package com.rucoding.java;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * @author LiuYiXin
 */
public class ThreadNewByCallable {
    public static void main(String[] args) {
        //3.创建Callable接口的实现类对象
        NumberPrint numberPrint = new NumberPrint();
        //4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(numberPrint);
        //5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
        Thread t1 = new Thread(futureTask);
        t1.start();

        //6.获取Callable中call方法的返回值
        Object sum = null;
        try {
            sum = futureTask.get();
            //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
            System.out.println("总和为:" + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

    }
}

//1.创建一个实现Callable的实现类
class NumberPrint implements Callable {
    //2.实现call方法，将此线程需要执行的操作声明在call()中
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0) {
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}

小结：

实现Callable接口:
> Future接口:
    >> 可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等。
    >> FutrueTask是Futrue接口的唯一的实现类。
    >> FutureTask 同时实现了Runnable, Future接口。它既可以作为Runnable被线程执行，
       又可以作为Future得到Callable的返回值。

6.2、创建多线程的方式之四_使用线程池

>> 背景描述:
	经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。

>> 思路分析:
	提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。
	可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。

>> 好处:
	>>> 提高响应速度（减少了创建新线程的时间）
	>>> 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
	>>> 便于线程管理:
		>>>> corePoolSize：核心池的大小
		>>>> maximumPoolSize：最大线程数
		>>>> keepAliveTime：线程没有任务时最多保持多长时间后会终止

代码演示：

package com.rucoding.java;

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * @author LiuYiXin
 */
public class ThreadPool {
    public static void main(String[] args) {
        //1. 提供指定线程数量的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(10);

        //想设置属性？ExecutorService是接口类哦，那怎么设置？
//        System.out.println(executorService.getClass());  //返回实际对象ThreadPoolExecutor
        ThreadPoolExecutor thExecutor = (ThreadPoolExecutor) executorService;
        //设置属性
//        thExecutor.setCorePoolSize(15);
//        thExecutor.getMaximumPoolSize();
//        thExecutor.setKeepAliveTime();


        //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        executorService.execute(new NumberThread());  // //适合适用于Runable
        executorService.execute(new NumberThread1());

        //3.关闭连接池
        executorService.shutdown();
    }
}

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

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

6.2.1、线程池相关API

线程池相关API:
>> JDK 5.0起提供了线程池相关API: ExecutorService 和 Executors
>> ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
	>>>  void execute(Runnable command) ：执行任务/命令，没有返回值，一般用来执行Runnable
	>>> <T> Future<T> submit(Callable<T> task)：执行任务，有返回值，一般用来执行Callable
	>>> void shutdown() ：关闭连接池
>> Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
  	>>> Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池
  	>>> Executors.newFixedThreadPool(n); 创建一个可重用固定线程数的线程池
  	>>> Executors.newSingleThreadExecutor() ：创建一个只有一个线程的线程池
  	>>> Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。

Rucoding Today~一键三连，好运连连连~