Java 多线程02(线程状态、线程同步)

Java 多线程02(线程状态、线程同步)

线程状态

Join合并线程：

等待此线程执行完成后，再执行其他线程，其他线程阻塞。

public class TestJoin implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 500; i++) {
            System.out.println("VIP线程来插队了" + i);
        }
    }
    public static void main(String[] args) throws InterruptedException {
        TestJoin testJoin = new TestJoin();
        Thread thread = new Thread(testJoin);
        for (int i = 0; i < 200; i++) {
            if (i == 20) {
                thread.start();
                thread.join();//主线程阻塞，VIP线程优先
            }
            System.out.println("主线程在运行" + i);
        }
    }
}

线程状态观测：

查看线程状态：

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);//New
        //观察启动后
        thread.start();//启动线程
        state=thread.getState();
        System.out.println(state);//Run

        while (state!=Thread.State.TERMINATED){//只要线程不终止，就一直输出状态
            Thread.sleep(100);
            state=thread.getState();//更新线程状态
            System.out.println(state);//输出状态
        }
    }
}

设置线程的优先级：(优先级最高为10，最小为1，不一定会优先运行，需要看CPU的调度)

public class TestPriority {
    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);
        //先设置优先级，再启动
        t1.start();

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

        t3.setPriority(4);
        t3.start();

        t4.setPriority(Thread.MAX_PRIORITY);
        t4.start();
    }
}
class MyPriority implements Runnable{
    @Override
    public void run() {        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
    }
}

守护(daemon)线程:

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

虚拟机必须确保用户线程执行完毕，不用等待守护线程执行完毕。如：后台记录操作日志，监控内存，垃圾回收。

用户线程结束之后，虚拟机停止，然后守护线程也随之结束。

Thread thread=new Thread();
thread.setDaemon(true);///true为守护线程。默认是false表示是用户线程。正常的线程都是用户线程

线程同步

并发：同一个对象被多个线程同时操作

synchronized锁的对象就是变化的量，需要增删改的对象

//线程不安全集合 加synchronized
public class UnsafeList {
    public static void main(String[] args) throws InterruptedException {
        List<String> list=new ArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                synchronized (list){
                    list.add(Thread.currentThread().getName());
                }
            }).start();
        }
        Thread.sleep(2000);
        System.out.println(list.size());
    }
}
//不加synchronized  list长度小于10000，加了synchronized代码块就会等于10000
       Thread.sleep(2000);
        System.out.println(list.size());
    }
}
//不加synchronized  list长度小于10000，加了synchronized代码块就会等于10000