Java-java线程：两个实现方法，死锁现象，线程通讯，线程停止等

1. 前言，前段时间一直在研究JavaWeb方向，最近闲下来，回过头来看看线程，又有不一样的见解。

package sh.thread;
public class ThreadDemo1 extends Thread{
    //1.自定义线程要执行的目标代码
    @Override
    public void run() {
        for(int i=0;i<10;i++){
            System.out.println("线程1："+i);
        }
    }
    public static void main(String[] args){
        //2.创建自定义线程类的对象
        ThreadDemo1 T1 = new ThreadDemo1();
        //3.调用start方法启动线程
        T1.start();
        for(int i=0;i<5;i++){//main主线程
            System.out.println("线程2："+i);
        }   
    }
}
/*
 * 1.线程基础知识：
 *   进程：正在执行的程序称作为一个进程。 进程负责了内存空间的划分。
 *   线程：线程在一个进程中 负责了代码的执行，就是进程中一个执行路径。
 *   多线程：在一个进程中有多个线程（多个不同路径），同时在执行不同的任务。
 * 
 * 2.多线程的好处：
 *   1.解决了一个进程能同时执行多个任务的问题。（高并发点击网页必须的！厉害吧，骚年！）
 *   2.提高了资源的利用率。
 * 
 * 3.多线程的弊端：
 *   1.增加cpu的的负担。
 *   2.降低了一个进程中线程的执行概率。
 *   3.引发了线程安全问题。
 *   3.出现了死锁现象。
 * 
 * 4.创建线程的方式：
 *   方法一：
 *       1.自定义一个类继承Thread类。
 *       2.重写Thread类的run方法，把自定义线程的任务代码写在run方法中
 *       (重写的目的：每个线程都有自己的任务代码，jvm创建的主线程的任务代码就是 
 *       main方法中的所有代码，而自定义线程的任务代码就写在run方法中)
 *       3.创建Thread的子类对象，并且调用start方法开启线程。
 *     注意：一个线程一旦开启，那么线程就会执行run方法中的代码，run方法千万不能直接调用，
 *          直接调用 就相当调用了一个普通的方法而并没有开启新的线程。
 * */

1. 用上面的一个基础线程，引出线程生命周期图，嗯，非常清晰了。
   

2. 线程的一些常用方法及注解

package sh.thread;

public class ThreadDemo2 extends Thread{
/*
 5. 线程常用的方法：
     Thread(String name)     初始化线程的名字
     setName(String name)    设置线程对象名
     getName()               返回线程的名字

     sleep()    静态：在哪个线程内，就是那个线程             线程睡眠指定的毫秒数。 静态的方法， 那个线程执行了sleep方法代码那么就是那个线程睡眠。

     currentThread()   静态：同上      返回当前的线程对象，该方法是一个静态的方法， 注意： 那个线程执行了currentThread()代码就返回那个线程 的对象。

     getPriority()             返回当前线程对象的优先级   默认线程的优先级是5
     setPriority(int newPriority) 设置线程的优先级    虽然设置了线程的优先级，但是具体的实现取决于底层的操作系统的实现（最大的优先级是10 ，最小的1 ， 默认是5）。
 */
    public ThreadDemo2(String name){
        super(name);//调用了Thread类的一个 参数的构造方法。
    }
    @Override
    public void run() {
        /*System.out.println("this:"+ this); //this对象与当前线程对象是同一个
        System.out.println("当前线程对象：" + Thread.currentThread()); */

        for (int i = 0; i < 100 ; i++) {//自定义线程目标代码
            System.out.println(Thread.currentThread().getName()+":"+i);         
            /*try {
                Thread.sleep(100);  //为什么在这里不能抛出异常，只能捕获？？ Thread类的run方法没有抛出异常类型，所以子类不能抛出异常类型（子类不能超过父类）
            } catch (InterruptedException e) {
                e.printStackTrace();
            } */
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //创建了一个线程对象
        ThreadDemo2 d = new ThreadDemo2("狗剩哥");
        d.setPriority(10); //设置线程 的优先级。 优先级的数字越大，优先级越高  ， 优先级的范围是1~10
        d.start();

        for (int i = 0; i < 100 ; i++) {//主线程目标代码
            System.out.println(Thread.currentThread().getName()+":"+i);
        }

        /*
        System.out.println("自定义线程的优先级："+d.getPriority());  //线程的优先级默认是5
        System.out.println("主线程的优先级："+Thread.currentThread().getPriority());

        d.start();
        d.setName("铁蛋"); //setName设置线程的名字
        d.start(); //开启线程 

        Thread mainThread = Thread.currentThread();
        System.out.println("主线程的名字："+ mainThread.getName());
    */
    }
}

4 .好吧，经典的多线程卖票问题，当时懵逼的有木有！，现在看来，不过尔尔…

package sh.thread;
/*
 1. 需求： 模拟3个窗口同时在售50张 票 。

问题1 ：为什么50张票被卖出了150次？

出现 的原因： 因为num是非静态的，非静态的成员变量数据是在每个对象中都会维护一份数据的,三个线程对象就会有三份。

 2. 解决方案：把num票数共享出来给三个线程对象使用。使用static修饰。

问题2： 出现了线程安全问题 ?

 3. 线程 安全问题的解决方案：sun提供了线程同步机制让我们解决这类问题的。

    java线程同步机制的方式：

        方式一：同步代码块

            同步代码块的格式：

                synchronized(锁对象){
                    需要被同步的代码...
                }

4. 同步代码块要注意事项：
        1. 任意的一个对象都可以做为锁对象。
        2. 在同步代码块中调用了sleep方法并不是释放锁对象的。
        3. 只有真正存在线程安全问题的时候才使用同步代码块，否则会降低效率的。
        4. 多线程操作的锁 对象必须 是唯一共享 的。否则无效。           
5. 出现线程安全问题的根本原因：
    1. 存在两个或者两个以上 的线程对象,而且线程之间共享着一个资源。
    2. 有多个语句操作了共享资源。
 */

class SaleTicket extends Thread{
     static int num = 50;//票数  非静态的成员变量,非静态的成员变量数据是在每个对象中都会维护一份数据的。

     static Object o = new Object();//定义一个唯一共享的锁对象
     public SaleTicket(String name) {
        super(name);
    }
    @Override
    public void run() {
        while(true){
            //同步代码块
            synchronized (o) {              
                if(num>0){
                    System.out.println(Thread.currentThread().getName()+"售出了第"+num+"号票");
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    num--;
                }else{
                    System.out.println("卖完了..");
                    break;
                }
            }
        }
    }   
} 

public class ThreadDemo3 {
    public static void main(String[] args) {
        //创建三个线程对象，模拟三个窗口
        SaleTicket thread1 = new SaleTicket("窗口1");
        SaleTicket thread2 = new SaleTicket("窗口2");
        SaleTicket thread3 = new SaleTicket("窗口3");
        //开启线程售票
        thread1.start();
        thread2.start();
        thread3.start();    
    }
}

5.线程通讯： 一个线程完成了自己的任务时，要通知另外一个线程去完成另外一个任务.
例子：生产者-消费者

package sh.thread;

/*
线程通讯： 一个线程完成了自己的任务时，要通知另外一个线程去完成另外一个任务.

生产者与消费者

wait():  等待   如果线程执行了wait方法，那么该线程会进入等待的状态，等待状态下的线程必须要被其他线程调用notify方法才能唤醒。
notify()： 唤醒    唤醒线程池等待线程其中的一个。
notifyAll() : 唤醒线程池所有等待 线程。

wait与notify方法要注意的事项：
    1. wait方法与notify方法是属于Object对象 的。
    2. wait方法与notify方法必须要在同步代码块或者是同步函数中才能 使用。
    3. wait方法与notify方法必需要由锁对象调用。

*/

//产品类
class Product{
    String name;
    double price;
    boolean flag = false; //判断产品是否已生产，默认没有生产完成。
}
//生产者
class Producter extends Thread{
    //1.引入产品类
    Product p;
    Producter(Product p){
        this.p = p;
    }
    @Override
    public void run() {
        int i = 0;
        while (true) {
            synchronized (p) {
                if(p.flag==false){
                    if(i%2==0){
                        p.name = "苹果";
                        p.price = 6.8;
                    }else {
                        p.name = "橡胶";
                        p.price = 2.0;
                    }
                    System.out.println("生产者生产出来："+p.name+" 价格："+p.price);
                    p.flag = true;
                    i++;
                    p.notifyAll();//唤醒消费者去消费,锁对象调用
                }else {
                    //已经生产了一个了，等待消费者先去消费
                    try {
                        p.wait(); //生产者等待
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }       
            }
        }

    }
}
//消费者
class Customer extends Thread{
    //引入产品类
    Product p;
    public Customer(Product p) {
        this.p = p;
    }

    @Override
    public void run() {
        while(true){
            synchronized (p) {
                if(p.flag){
                    System.out.println("消费者消费了："+p.name+" 价格："+p.price);
                    p.flag = false;//消费一下就停了
                    p.notifyAll();
                }else {
                    try {//停止消费
                        p.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }   
}
public class ThreadDemo5 {

    public static void main(String[] args){
        Product p = new Product();
        Producter producter = new Producter(p);
        Customer customer = new Customer(p);
        producter.start();
        customer.start();
    }
}

6.线程的停止的 两个方法

package sh.thread;

/*
 * 线程的停止：
 *  1.停止一个线程  我们一般都会通过一个变量去控制的。
 *  2.如果需要停止一个处于等待状态下的线程，那么我们需要通过变量配合
 *  notify方法或者interrupt()来使用。
 *notify：是唤醒它，它运行完了，自然就停止了，必须在锁对象内
 *interrupt：直接把它的等待状态强制清除！
 * */
public class Thread6 extends Thread{
    boolean flag = true;//停止线程的标识
    public Thread6(String name){
        super(name);
    }
    //自定义一个一开始就等待的线程，来停掉它！
    @Override
    public synchronized void run() {
        while(flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                System.out.println("已停止，且捕获异常了");
            }
        }
    }

    public static void main(String[] args) {
        Thread6 t6 = new Thread6("小二");
        t6.start();//开始自定义线程

        for(int i=0;i<10;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
            if(i==8){
                t6.flag = false;//让t6线程跳出循环
                //停止线程方法1：唤醒它，自然停止
                /*synchronized (t6) {
                    t6.notify();
                }*/
                //停止线程方法2：interrupt强制清除它的等待状态:会抛出一个异常
                t6.interrupt();
            }
        }
    }
}

7 . 守护线程详解

package sh.thread;
/*
 守护线程（后台线程）:在一个进程中如果只剩下 了守护线程，那么守护线程也会死亡。

 //如果一个线程随着你的主线程存在就存在，随着主线程消亡就消亡，那就可以将它设置为后台线程
 //守护线程：做下载更新包... 
 需求： 模拟QQ下载更新包。

 一个线程默认都不是守护线程。
 */
public class Thread7 extends Thread {

    public Thread7(String name){
        super(name);
    }

    @Override
    public void run() {
        for(int i = 1 ; i<=10 ; i++){
            System.out.println("更新包目前下载"+i+"%");
            if(i==10){
                System.out.println("更新包下载完毕,准备安装..");
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {

        Thread7 d = new Thread7("后台线程");
         d.setDaemon(true); //setDaemon() 设置线程是否为守护线程，true为守护线程， false为非守护线程。
        // System.out.println("是守护线程吗？"+ d.isDaemon()); //判断线程是否为守护线程。
         d.start();
         for(int i = 1 ; i<=10 ; i++){
 System.out.println(Thread.currentThread().getName()+":"+i);
         }
    }
}

8 . 线程中的 join方法

package cn.itcast.thread;
/*
 join方法。 加入
 */
//老妈
class  Mon extends Thread{

    public void run() {
        System.out.println("妈妈洗菜");
        System.out.println("妈妈切菜");
        System.out.println("妈妈准备炒菜，发现没有酱油了..");
        //叫儿子去打酱油
        Son s= new Son();
        s.start();
        try {
            s.join();  //加入。 一个线程如果执行join语句，那么就有新的线程加入，执行该语句的线程必须要让步给新加入的线程先完成任务，然后才能继续执行。
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("妈妈继续炒菜");
        System.out.println("全家一起吃饭..");     
    }
} 
class Son extends Thread{
    @Override
    public void run() {
        System.out.println("儿子下楼..");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("儿子一直往前走");
        System.out.println("儿子打完酱油了");
        System.out.println("上楼，把酱油给老妈");
    }
}
public class Demo8 {
    public static void main(String[] args) {
        Mon m = new Mon();
        m.start();
    }
}