Java--多线程--线程状态、线程优先级、守护线程、线程不安全三案例以及synchronized关键字

最新推荐文章于 2024-07-13 13:55:40 发布

m0_37570287

最新推荐文章于 2024-07-13 13:55:40 发布

阅读量51

点赞数

分类专栏： Java基础文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/m0_37570287/article/details/129721493

版权

Java基础专栏收录该内容

12 篇文章 0 订阅

订阅专栏

Java–多线程–线程状态、线程优先级、守护线程、线程不安全三案例以及synchronized关键字

线程状态

package com.zy.thread;

/**
 *description: Java--多线程--线程状态观察
 *@program: 基础语法
 *@author: zy
 *@create: 2023-03-22 20:55
 */
public class StudyThreadState {



    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();
        // 新生 NEW
        System.out.println(state);
        // 观察启动后
        thread.start();
        // 运行状态 RUNNABLE
        state = thread.getState();
        System.out.println(state);

        while (state != Thread.State.TERMINATED){
            Thread.sleep(100);
            // 更新状态 TIMED_WAITING/TERMINATED
            state = thread.getState();
            System.out.println(state);
        }

        /*
        死亡之后的线程无法再次启动
         */
        //thread.start();
    }
}

线程优先级

package com.zy.thread;

/**
 *description: Java--多线程--线程优先级
 *@program: 基础语法
 *@author: zy
 *@create: 2023-03-22 21:07
 */
public class StudyThreadPriority {

    /*
    优先级的设置建议在启动之前；
    优先级低只是意味着cpu调度的概率低，并不保证不调用。（性能倒置）
     */

    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);

        // 设置优先级
        t2.setPriority(Thread.MIN_PRIORITY);
        t3.setPriority(4);
        t4.setPriority(Thread.MAX_PRIORITY);

        t1.start();
        t2.start();
        t3.start();
        t4.start();

        /*t5.setPriority(-1);
        t5.start();

        t6.setPriority(11);
        t6.start();*/
    }
}

class MyPriority implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"--->"+Thread.currentThread().getPriority());
    }
}

守护线程

package com.zy.thread;

/**
 *description: Java--多线程--守护线程
 *@program: 基础语法
 *@author: zy
 *@create: 2023-03-22 21:20
 */
public class StudyThreadDaemon {

    /*
    线程分为用户线程和守护线程；
    虚拟机必须确保用户线程执行完毕；
    虚拟机不用等待守护线程执行完毕；
    例子：后台记录操作日志，监控内存，垃圾回收等待...
     */

    public static void main(String[] args) {

        God god = new God();
        Person person = new Person();

        Thread thread = new Thread(god);
        // 设置守护线程；默认false，标识为用户线程
        thread.setDaemon(true);
        // 守护线程启动
        thread.start();
        // 用户线程启动
        new Thread(person).start();
    }
}

class God implements Runnable{

    @Override
    public void run() {
        while (true){
            System.out.println("上帝保佑着你");
        }
    }
}

class Person implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 36500; i++) {
            System.out.println("你这一生都开心的活着");
        }
        System.out.println("==========再见，世界！！！===========");
    }
}

线程不安全案例

package com.zy.thread.sync;

/**
 *description: Java--多线程--线程不安全买票案例
 * 线程不安全：数据不一致
 *@program: 基础语法
 *@author: zy
 *@create: 2023-03-22 21:41
 */
public class UnsafeBuyTicket {

    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();

        new Thread(buyTicket,"小米").start();
        new Thread(buyTicket,"小张").start();
        new Thread(buyTicket,"小王").start();
    }
}

class BuyTicket implements Runnable{

    private int ticketNumbers = 10;
    boolean flag = true;

    @Override
    public void run() {
        while (flag){
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * @Description 同步方法，锁的是this本身这个对象
     * @author zy
     * []
     * void
     * @date 2023-3-22 22:43
     */
    private synchronized void buy() throws InterruptedException {
        if(ticketNumbers <=0){
            flag = false;
            return;
        }

        Thread.sleep(100);

        System.out.println(Thread.currentThread().getName()+"拿到了第"+ticketNumbers--+"张票");
    }
}

package com.zy.thread.sync;

/**
 *description: Java--多线程--不安全取钱案例
 *@program: 基础语法
 *@author: zy
 *@create: 2023-03-22 21:51
 */
public class UnsafeBank {

    public static void main(String[] args) {

        Account account = new Account(1000,"买房的钱");

        Drawing boy = new Drawing(account,50,"你");
        Drawing girl = new Drawing(account,100,"女朋友");

        boy.start();
        girl.start();
    }
}

class Account{
    private int money;
    private String name;

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }

    public int getMoney() {
        return money;
    }
    public void setMoney(int money) {
        this.money = money;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

class Drawing extends Thread{
    private Account account;
    private int drawingMoney;
    private int nowMoney;

    public Drawing(Account account,int drawingMoney,String name){
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;
    }

    @Override
    public void run() {

        // 同步块，又叫同步监视器，建议锁共享资源，需要访问修改的资源
        synchronized (account){
            if(account.getMoney() - drawingMoney < 0){
                System.out.println(this.getName()+"余额不足，无法提取");
                return;
            }

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

            account.setMoney(account.getMoney()-drawingMoney);
            nowMoney = nowMoney + drawingMoney;

            System.out.println(account.getName()+"余额为："+account.getMoney());
            System.out.println(this.getName()+"手里的钱为："+nowMoney);
        }


    }
}

package com.zy.thread.sync;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

/**
 *description: Java--多线程--线程不安全的集合案例
 *@program: 基础语法
 *@author: zy
 *@create: 2023-03-22 22:13
 */
public class UnsafeList {

    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                synchronized (list){
                    list.add(Thread.currentThread().getName());
                    System.out.println("List大小："+list.size()+"===>"+Thread.currentThread().getName());
                }
            }).start();
        }

    }
}