JAVA学习笔记05——线程基础02

2021年7月23日

线程终止

线程完成任务之后会自动退出
还可以通过使用变量来控制run方法退出，来停止线程，即通知方式

public class ThreadExit {
    public static void main(String[] args) {
        Thread4 thread4 = new Thread4();
        thread4.start();
        // 如果希望main控制t1线程终止，可以修改loop
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thread4.setLoop(false);
    }
}
class Thread4 extends Thread {
    private int count = 0;
    private boolean loop = true;
    @Override
    public void run() {
        while (loop) {
            System.out.println("运行中……"+count);
            count++;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public void setLoop(boolean b) {
        this.loop = b;
    }
}

线程常用方法1

setName() 设置线程名称，使之与参数name相同
getName() 返回该线程的名称
start() 使该线程开始执行；java虚拟机底层调用该线程的start0方法
run() 调用线程对象run方法
setPriority() 更改线程的优先级
getPriority() 获取线程的优先级
sleep() 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）
interrupt() 中断线程

注意事项和细节

start底层会创建新的线程，调用run，run就是一个简单的方法调用，不会启动新线程
线程优先级的范围：默认5，最小1，最大10
interrupt,中断线程，但并没有真正的结束线程。所以一般用于中断正在休眠的线程
sleep，线程的静态方法，使当前线程休眠

线程常用方法2

yield，线程的礼让。让出CPU，让其他线程执行，但礼让的时间不确定，所以也不一定礼让成功

join，线程的插队。插队的线程一旦插队成功，则肯定先执行完插入的线程所有的任务

案例：创建一个子线程，每隔一秒输出hello，输出20次，主线程每隔1秒，输出hi，输出20次。要求：两个线程同时执行，当主线程输出5次后，就让子线程运行完毕，主线程再继续。

public class ThreadMethod {
    public static void main(String[] args) throws InterruptedException {
        Eat eat = new Eat();
        eat.setName("老大");
        eat.start();
        Thread.currentThread().setName("小弟");
        for (int i = 0; i < 30; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "吃了" + (i+1) +"个汉堡");
            if (i == 5) {
                System.out.println("大哥先吃");
                eat.join(); // 这里相当于让eat先执行
                System.out.println("大哥吃完了，小弟吃");
            }
        }
    }
}

class Eat extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "吃了" + (i+1) +"个汉堡");
        }
    }
}

线程常用方法3

用户线程和守护线程
- 用户线程：也叫工作线程，当线程的任务执行完或通知方式结束
- 守护线程：一般使为工作线程服务的，当所有的用户线程结束，守护线程自动结束
- 常见的守护线程：垃圾回收机制

public class DaemonThread {
    public static void main(String[] args) {
        MyDaemonThread myDaemonThread = new MyDaemonThread();
        // 如果我们希望当main线程结束时，mydaemonthread线程自动结束，需要将其设置为守护线程
        myDaemonThread.setDaemon(true);
        // 先设置守护线程再启动
        myDaemonThread.start();
        for (int i = 0; i < 20; i++) {
            System.out.println("Idols are singing.");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class MyDaemonThread extends Thread{
    @Override
    public void run() {
        while (true) {
            System.out.println("Ships are chatting……");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

线程的生命周期

JDK中用Thread.State枚举表示了线程的几种状态
- NEW
  
  尚未启动的线程处于此状态
- RUNNABLE
  
  在java虚拟机中执行的线程处于此状态
- BLOCKED
  
  被阻塞等待监视器锁定的线程处于此状态
- WAITING
  
  正在等待另一个线程执行特定动作的线程处于此状态
- TIMED_WAITING
  
  正在等待另一个线程执行动作达到指定等待时间的线程处于此状态
- TERMINATED
  
  已退出的线程处于此状态
未命名文件 (2).jpg

public class ThreadState {
    public static void main(String[] args) {
        TS ts = new TS();
        System.out.println(ts.getName() + "状态" + ts.getState());
        ts.start();
        while (Thread.State.TERMINATED != ts.getState()) {
            System.out.println(ts.getName() + "状态" +ts.getState());
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(ts.getName() + "状态" +ts.getState());
    }
}

class TS extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "run " + i +"times");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

运行结果：

Thread-0状态NEW
Thread-0状态RUNNABLE
Thread-0run 0times
Thread-0状态TIMED_WAITING
Thread-0状态TIMED_WAITING
Thread-0run 1times
Thread-0状态TIMED_WAITING
Thread-0run 2times
Thread-0状态TIMED_WAITING
Thread-0状态TIMED_WAITING
Thread-0run 3times
Thread-0状态TIMED_WAITING
Thread-0状态TIMED_WAITING
Thread-0run 4times
Thread-0状态TIMED_WAITING
Thread-0状态TIMED_WAITING
Thread-0run 5times
Thread-0状态TIMED_WAITING
Thread-0状态TIMED_WAITING
Thread-0run 6times
Thread-0状态TIMED_WAITING
Thread-0状态TIMED_WAITING
Thread-0run 7times
Thread-0状态TIMED_WAITING
Thread-0状态TIMED_WAITING
Thread-0run 8times
Thread-0状态TIMED_WAITING
Thread-0状态TIMED_WAITING
Thread-0run 9times
Thread-0状态TIMED_WAITING
Thread-0状态TIMED_WAITING
Thread-0状态TERMINATED

线程同步机制

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

同步具体方法-Synchronized

同步代码块

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

synchronized还可以放在方法声明中，表示整个方法为同步方法
```
public synchronized void m(String name) {
    // 需要被同步的代码
}
```

使用synchronized解决售票问题

public class Syc {
    public static void main(String[] args) {
        SellTicket sellTicket = new SellTicket();
        new Thread(sellTicket).start();
        new Thread(sellTicket).start();
        new Thread(sellTicket).start();
    }
}
class SellTicket implements Runnable {
    private int ticketNum = 500;
    private boolean loop = true;
    public synchronized void sell() {
        // 同步方法，在同一个时刻，只能有一个线程执行run方法
        if (ticketNum <= 0) {
            System.out.println("票已售完，售票结束");
            loop = false;
            return;
        }

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

        ticketNum--;
        System.out.println(Thread.currentThread().getName() + "售出票，剩余票数" + ticketNum);
    }

    @Override
    public  void run() {
        while (loop) {
            sell();
        }
    }
}

互斥锁

基本介绍

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

注意事项和细节

同步方法如果没有使用static修饰：默认锁对象为this
如果方法使用static修饰，默认锁对象：当前类.class
实现落地步骤：
- 需要分析上锁代码
- 选择同步代码块或同步方法
- 要求多个线程的锁对象为同一个即可

线程的死锁

基本介绍

多个线程都占用了对方的锁资源，但不肯相让，导致了死锁，编程时一定要避免死锁的发生

public class DeadSyc {
    public static void main(String[] args) {
        // 模拟死锁现象
        DeadT deadT1 = new DeadT(true);
        DeadT deadT2 = new DeadT(false);
        deadT1.setName("A线程");
        deadT2.setName("B线程");
        deadT1.start();
        deadT2.start();
    }
}

class DeadT extends Thread {
    static Object o1 = new Object();
    static Object o2 = new Object();
    boolean flag = true;

    public DeadT(boolean b) {
        this.flag = b;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }
    @Override
    public void run() {
        // 业务逻辑分析
        // 如果flag为true，线程1就会先得到o1锁，尝试获取o2锁
        // 如果获得o2失败，线程1则会blocked
        // 如果flag为false，线程2会先得到o2锁，尝试获取o1锁
        // 如果获得o1失败，线程2则会blocked
        if (flag) {
            synchronized (o1) {
                System.out.println(Thread.currentThread().getName() + "进入1");
                synchronized (o2) {
                    System.out.println(Thread.currentThread().getName() + "进入2");
                }
            }
        } else {
            synchronized (o2) {
                System.out.println(Thread.currentThread().getName() + "进入3");
                synchronized (o1) {
                    System.out.println(Thread.currentThread().getName() + "进入4");
                }
            }
        }
    }
}

释放锁

释放锁的操作

当前线程的同步方法、同步代码执行结束
当前线程在同步代码块、同步方法中遇到break,return
当前线程在同步代码块、同步代码中出现了Error和Exception，导致异常结束
当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁

不释放锁的操作

线程执行同步代码或同步方法时，程序调用Thread.sleep(),Thread.yield()方法暂停当前线程的执行，不会释放锁
线程执行同步代码块时，其他线程调用了该线程的suspend()方法将线程挂起，不会释放锁

JAVA学习笔记05——线程基础02

线程终止

线程常用方法1

注意事项和细节

线程常用方法2

线程常用方法3

线程的生命周期

线程同步机制

互斥锁

基本介绍

注意事项和细节

线程的死锁

基本介绍

释放锁

释放锁的操作

不释放锁的操作

推荐阅读更多精彩内容