day33-线程基础03

线程基础03

6.用户线程和守护线程

1. 用户线程：也叫工作线程，当线程的任务执行完或者通知方法结束。平时用到的普通线程均是用户线程，当在Java程序中创建一个线程，它就被称为用户线程

2. 守护线程（Daemon）：一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束

3. 常见的守护线程：垃圾回收机制

例子1：如何将一个线程设置成守护线程

package li.thread.method;public class ThreadMethodExercise {    public static void main(String[] args) throws InterruptedException {                MyDaemonThread myDaemonThread = new MyDaemonThread();                //如果我们希望当主线程结束后，子线程自动结束，只需要将子线程设置为守护线程        myDaemonThread.setDaemon(true);                myDaemonThread.start();                for (int i = 1; i <= 10; i++) {//main线程            System.out.println("悟空在前方打妖精...");            Thread.sleep(1000);        }    }}class MyDaemonThread extends Thread {    @Override    public void run() {        for (; ; ) {//无限循环            try {                Thread.sleep(1000);            } catch (InterruptedException e) {                e.printStackTrace();            }            System.out.println("八戒收拾东西回高老庄...");        }    }}

7.线程的生命周期

• JDK中用Thread.State枚举表示了线程的几种状态：

例子

package li.thread.state;public class ThreadState_ {    public static void main(String[] args) throws InterruptedException {        T t = new T();        System.out.println(t.getName() + "状态 " + t.getState());        t.start();        while (t.getState() != Thread.State.TERMINATED) {            System.out.println(t.getName() + "状态 " + t.getState());            Thread.sleep(1000);        }        System.out.println(t.getName() + "状态 " + t.getState());    }}class T extends Thread {    @Override    public void run() {        for (int i = 0; i < 10; i++) {            System.out.println("hi" + i);            try {                Thread.sleep(1000);            } catch (InterruptedException e) {                e.printStackTrace();            }        }    }}

8.线程同步机制

• 线程同步机制

1. 在多线程编程中，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任何同一时刻，最多有一个线程访问，以保证数据的完整性。
2. 也可以理解为：线程同步，即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作，其他线程才能对该内存地址进行操作。

• 同步具体方法--Synchronized

1. 同步代码块

   synchronized(对象){//得到对象的锁，才能操作同步代码	//需要被同步的代码}

2. synchronized还可以放在方法声明中，表示整个方法为同步方法

   public synchronized void m(String name){    //需要被同步的代码}

   就好像某个小伙伴上厕所之前先把门关上（上锁），完事之后再出来（解锁），那么其他小伙伴就可以再使用厕所了

例子：使用synchronized解决3.1售票问题

package li.thread.syn;//使用多线程，模拟三个窗口同时售票共100张public class SynSellTicket {    public static void main(String[] args) {        SellTicket03 sellTicket03 = new SellTicket03();        new Thread(sellTicket03).start();//第1个线程-窗口        new Thread(sellTicket03).start();//第2个线程-窗口        new Thread(sellTicket03).start();//第3个线程-窗口    }}//实现接口方式，使用synchronized实现线程同步class SellTicket03 implements Runnable {    private int ticketNum = 100;    private boolean loop = true;//控制run方法变量    public synchronized void sell() {//同步方法，在在同一时刻，只能有一个线程来执行run方法        if (ticketNum <= 0) {            System.out.println("售票结束...");            loop = false;            return;        }        //休眠50毫秒,模拟        try {            Thread.sleep(50);        } catch (InterruptedException e) {            e.printStackTrace();        }        System.out.println("窗口：" + Thread.currentThread().getName() + "售出一张票 "                + "剩余票数：" + (--ticketNum));    }    @Override    public void run() {        while (loop) {            sell();//sell方法是一个同步方法        }    }}

8.1互斥锁

• 基本介绍

1. Java语言中，引入了对象互斥锁的额概念，来保证共享数据操作的完整性
2. 每一个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象
3. 关键字synchronized来与对象的互斥锁联系。当某个对象用synchronized修饰时，表明该对象在任一时刻只能有一个线程访问
4. 同步的局限性：导致程序的执行效率降低
5. 非静态的同步方法，锁可以是this（当前对象），也可以是其他对象（要求锁的是同一个对象）
6. 同步方法（静态的）的锁为当前类本身（类.class）

synchronized实现同步的基础：Java中的每一个对象都可以作为锁。
具体表现为以下3种形式。
对于普通同步方法，锁是当前实例对象。
对于静态同步方法，锁是当前类的Class对象。
对于同步方法块，锁是Synchonized括号里配置的对象。

• 注意事项和细节：
  • 同步方法如果没有使用static修饰：默认锁对象为this
  • 如果方法使用static修饰，默认锁对象：当前类.class
  • 实现的落地步骤：
    • 需要先分析上锁的代码
    • 选择同步代码块或者同步方法
    • 要求多个线程的锁对象为同一个

package li.thread.syn;//使用多线程，模拟三个窗口同时售票共100张public class SynSellTicket {    public static void main(String[] args) {        SellTicket03 sellTicket03 = new SellTicket03();        new Thread(sellTicket03).start();//第1个线程-窗口        new Thread(sellTicket03).start();//第2个线程-窗口        new Thread(sellTicket03).start();//第3个线程-窗口    }}//实现接口方式，使用synchronized实现线程同步class SellTicket03 implements Runnable {    private int ticketNum = 100;    private boolean loop = true;//控制run方法变量    Object object = new Object();    //1.public synchronized static void m1(){}的锁加在SellTicket03.class    public synchronized static void m1(){}    //2.如果在静态方法中，要实现一个同步代码块则应该这样写：（原因是静态方法适合类一起加载的，静态方法不能使用this）    public static void m2(){        synchronized (SellTicket03.class){            System.out.println("m2");        }    }    // public synchronized void sell() {}就是一个同步方法。这时，锁在this对象    //也可以在代码块上写synchronized，同步代码块,互斥锁还是在this对象    public /*synchronized*/void sell() {//同步方法        synchronized (/*this*/object) {//如果是new Object就不是同一个对象            if (ticketNum <= 0) {                System.out.println("售票结束...");                loop = false;                return;            }            //休眠50毫秒,模拟            try {                Thread.sleep(50);            } catch (InterruptedException e) {                e.printStackTrace();            }            System.out.println("窗口：" + Thread.currentThread().getName() + "售出一张票 "                    + "剩余票数：" + (--ticketNum));        }    }    @Override    public void run() {        while (loop) {            sell();//sell方法是一个同步方法        }    }}

8.2线程的死锁

• 基本介绍：

多个线程都占用了对方的锁资源，但不肯相让，导致了死锁。

在编程中一定要避免死锁的发生。

例子：

package li.thread.syn;//模拟线程死锁public class DeadLock_ {    public static void main(String[] args) {        //模拟死锁现象        DeadLockDemo A = new DeadLockDemo(true);        DeadLockDemo B = new DeadLockDemo(false);        A.setName("A线程");        B.setName("B线程");        A.start();        B.start();    }}class DeadLockDemo extends Thread {    static Object o1 = new Object();//保证多线程，共享一个对象，这里使用static    static Object o2 = new Object();    boolean flag;    public DeadLockDemo(boolean flag) {//构造器        this.flag = flag;    }    @Override    public void run() {        //下面业务逻辑的分析        //1.如果flag为true，线程就会先得到/持有 o1对象锁，然后尝试去获取o2对象锁        //2.如果线程A得不到o2对象锁，就会Blocked        //3.如果flag为false，线程B就会先得到/持有 o2对象锁，然后尝试去获取o1对象锁        //4.如果线程B得不到o1对象锁，就会Blocked        if (flag) {            synchronized (o1) {//对象互斥锁，下面就是同步代码                System.out.println(Thread.currentThread().getName() + "进入1");                synchronized (o2) {//这里获得li对象的监视权                    System.out.println(Thread.currentThread().getName() + "进入2");                }            }        } else {            synchronized (o2) {                System.out.println(Thread.currentThread().getName() + "进入3");                synchronized (o1) {//这里获得li对象的监视权                    System.out.println(Thread.currentThread().getName() + "进入4");                }            }        }    }}

如下图：两个线程卡住了

8.3释放锁

下面操作会释放锁：

1. 当前线程的同步方法、同步代码块执行结束
2. 当前线程在同步代码块、同步方法中遇到break、return
3. 当前线程在同步代码块、同步方法中出现了未处理的Error或者Exception，导致异常结束
4. 当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁

下面的操作不会释放锁：

1. 线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行，不会释放锁

2. 线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁。

? 提示：应尽量避免使用suspend()和resume()来控制线程，这两个方法不再推荐使用

9.本章作业

9.1线程HomeWork01

（1）在main方法中启动两个线程

（2）第一个线程循环随机打印100以内的整数

（3）直到第二个线程从键盘读取了“Q”命令

练习：

package li.thread.syn.homework;import java.util.Scanner;//（1）在main方法中启动两个线程public class ThreadHomeWork01 {    public static void main(String[] args) {        A a = new A();        B b = new B(a);//注意把a对象传入b构造器中        a.start();        b.start();    }}//创建A线程类class A extends Thread {    private boolean loop = true;    @Override    public void run() {        while (loop) {            System.out.println((int) (Math.random() * 100 + 1));            try {                Thread.sleep(1000);            } catch (InterruptedException e) {                e.printStackTrace();            }        }        System.out.println("a线程退出...");    }    public void setLoop(boolean loop) {        this.loop = loop;    }}//创建B线程类class B extends Thread {    private A a;    Scanner scanner = new Scanner(System.in);    public B(A a) {        this.a = a;    }    @Override    public void run() {        while (true) {            //接到用户输入            System.out.println("请输入你的指令(Q)表示退出");            char key = scanner.next().toUpperCase().charAt(0);            if (key == 'Q') {                //以通知的方式结束a线程                a.setLoop(false);                System.out.println("b线程退出...");                break;            }        }    }}

9.2线程线程HomeWork02

（1）有两个用户分别从同一张卡上取钱（总额10000）

（2）每次都取1000，当余额不足时，就不能取款了

（3）不能出现超取现象==>线程同步问题

易错点：关于互斥锁的理解
对于普通同步方法，锁是当前实例对象。
对于静态同步方法，锁是当前类的Class对象。
对于同步方法块，锁是Synchonized括号里配置的对象

package li.thread.syn.homework;public class ThreadHomeWork02 {    public static void main(String[] args) {        T t = new T();        Thread thread1 = new Thread(t);        Thread thread2 = new Thread(t);        thread1.setName("t1");        thread2.setName("t2");        thread1.start();        thread2.start();    }}class T implements Runnable {    private int money = 10000;    @Override    public void run() {        while (true) {//while不要放到同步代码块里面            //1.使用了synchronized实现线程同步            //2.当多个线程执行到这里的时候就会去争夺 this对象锁            //3.哪个线程争夺到（获取）this对象锁，就执行synchronized代码块            //4.争夺不到this对象锁，就Blocked，准备继续争夺            //5.this对象锁是非公平锁            synchronized (this) {                if (money <= 0) {                    System.out.println("余额不足...");                    break;                }                money -= 1000;                System.out.println(Thread.currentThread().getName() + "取出了1000元" + " 当前余额为：" + money);            }            try {                Thread.sleep(1000);            } catch (InterruptedException e) {                e.printStackTrace();            }        }    }}