Java多线程详解——Part two

线程状态观测

---

Thread.getState() 可以获得线程当前的状态

在getState()函数内部，线程的所有状态以枚举的形式被列举出来

public class TestState {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("/");
        });

        //观测启动前状态
        Thread.State state = thread.getState();
        System.out.println(state);

        //观测启动后状态
        thread.start();
        state = thread.getState();
        System.out.println(state);

        //持续监测线程状态直到结束
        while(state!=Thread.State.TERMINATED){
            Thread.sleep(100);
            state = thread.getState();//更新线程状态
            System.out.println(state);
        }
    }
}

线程的优先级

---

优先级用数字表示，范围从1-10

• Thread.MIN_PRIORITY = 1;
• Thread.MAX_PRIORITY = 10;
• Thread.NORM_PRIORITY = 5;

测试线程的优先级

• getPriority() 获取优先级
• setPriority() 设置优先级

public class ThreadPriority {
    public static void main(String[] args) {//打印主线程的优先级
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());

        MyPriority myPriority = new MyPriority();
        Thread t1 = new Thread(myPriority);
        Thread t2 = new Thread(myPriority);
        Thread t3 = new Thread(myPriority);
        Thread t4 = new Thread(myPriority);
        Thread t5 = new Thread(myPriority);
        Thread t6 = new Thread(myPriority);

        //设置优先级并启动
        t1.start();

        t2.setPriority(1);
        t2.start();

        t3.setPriority(Thread.MAX_PRIORITY);
        t3.start();

        t4.setPriority(4);
        t4.start();

    }
}

class MyPriority implements Runnable{
    @Override
    public void run() {
        //获取当前进程的名称和优先级
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
    }
}

守护线程

---

线程分为用户线程和守护线程

• 虚拟机必须确保用户线程执行完毕
• 虚拟机不用等待守护线程执行完毕
• 守护线程：记录操作日志、垃圾回收等

测试守护线程

• Thread.setDaemon(true/false)

  默认值为false(用户线程) 设置为true之后变为守护线程

线程同步

---

并发问题：多线程访问同一个对象

线程同步其实就是一个等待机制，多个需要同时访问此对象地线程进入这个对象地等待池形成队列，等待前面地线程使用完毕，下一个线程再使用

解决线程同步地安全性：队列+锁

锁机制：synchronized

不安全举例

public class ThreadSafe {
    public static void main(String[] args) {
        Account account = new Account(100,"结婚基金");

        DrawingMoney me = new DrawingMoney(account,50,"我");
        DrawingMoney wife = new DrawingMoney(account,100,"我妻子");

        me.start();
        wife.start();
    }
}

//银行账户
class Account{
    int money;
    String name;

    //构造方法
    public Account(int money,String name){
        this.money = money;
        this.name = name;
    }
}

//取钱
class DrawingMoney extends Thread{
    Account account;//账户名称
    int drawingmoney;//要取得钱
    int nowmoney;//手里有的钱

    @Override
    public void run() {
        if(account.money-drawingmoney<0){
            return;
        }

        //sleep可以放大问题的发生性
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        account.money = account.money - drawingmoney;
        nowmoney = nowmoney + drawingmoney;

        System.out.println(account.name+"余额为:"+account.money);
        System.out.println(this.getName()+"手里的钱为:"+nowmoney);
    }

    //构造方法
    public DrawingMoney(Account account,int drawingmoney,String name){
        super(name);
        this.account = account;
        this.drawingmoney = drawingmoney;
    }
}