Java学习Day14 线程同步锁

最新推荐文章于 2024-07-09 16:46:46 发布

御狐王

最新推荐文章于 2024-07-09 16:46:46 发布

阅读量16

点赞数

文章标签： java 学习开发语言

本文链接：https://blog.csdn.net/yuhuwangxy/article/details/133782271

版权

Java学习Day14 线程同步锁

在这里插入图片描述

线程的状态

/*官方声明6种状态
public static enum Thread.state.extends Enum<Thread.state>
线程状态。线程可以处于以下状态之一:
NEW
尚未启动的线程处于此状态。
RUNNABLE (代表可以执行 但具体是否运行由操作系统内核决定)
这个状态下还有 Ready Running 所以还有说法是7种状态
在Java虚拟机中执行的线程处于此状态。
BLOCKED
被阻塞等待监视器锁定的线程处于此状态。
WAITING
正在等待另一个线程执行特定动作的线程处于此状态。
TIMED_WAITING
正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。
TERMINATED
已退出的线程处于此状态。
 */
public class ThreadState {
    public static void main(String[] args) throws InterruptedException {
        S s = new S();
        System.out.println(s.getName() + " " + s.getState());
        s.start();
        //当main线程状态和s线程状态不同时输出状态名
        while (Thread.State.TERMINATED != s.getState()) {
            System.out.println(s.getName() + " " + s.getState());
            Thread.sleep(500);
        }
        System.out.println(s.getName() + " " + s.getState());
    }
}

class S extends Thread {
    @Override
    public void run() {
        while (true) {
            for (int i = 0; i < 10; i++) {
                System.out.println(i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            break;
        }
    }
}

线程退出

public class ThreadExit {
    public static void main(String[] args) throws InterruptedException {
        T t1 = new T();
        t1.start();

        //在主线程中控制t1线程的终止 必须修改loop 让t1退出run方法 终止t1线程
        //这种方法 成为通知终止
        Thread.sleep(5000);//休眠5s
        t1.setLoop(false);
    }
}
class T extends Thread{
    private int count = 0;
    private boolean loop =true;
    @Override
    public void run() {
        while (loop){
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("T 运行中..."+count++);
        }
    }

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

线程同步

/*为什么要线程同步呢？
使用多线程 模拟三个窗口同时售票
 */
public class SellTicket {
    public static void main(String[] args) {
        //会导致超卖 因为3个线程同时读取nums然而第一个读取还没有来的及卖票下一个就已经卖了
//        SellTicket01 sellTicket01 = new SellTicket01();
//        SellTicket01 sellTicket02 = new SellTicket01();
//        SellTicket01 sellTicket03 = new SellTicket01();
//        sellTicket01.start();
//        sellTicket02.start();
//        sellTicket03.start();
        //同样会出现超卖
//        SellTicket02 sellTicket02 = new SellTicket02();
//        new Thread(sellTicket02).start();
//        new Thread(sellTicket02).start();
//        new Thread(sellTicket02).start();

    }
}

//继承Tread
class SellTicket01 extends Thread {

    public static int nums = 100;

    public void run() {
        while (true) {

            if (nums <= 0) {
                System.out.println("票卖完了");
                break;
            }
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("窗口" + Thread.currentThread().getName() + "剩余" + (--nums));

        }
    }
}

//实现Runnable
class SellTicket02 implements Runnable {
    public static int nums = 100;

    @Override
    public void run() {
        while (true) {

            if (nums <= 0) {
                System.out.println("票卖完了");
                break;
            }
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("窗口" + Thread.currentThread().getName() + "剩余" + (--nums));

        }
    }
}
/*
1.在多线程编程，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技
术，保证数据在任何同一时刻，最多有一个线程访问，以保证数据的完整性。
2.也可以这里理解:线程同步，即当有一个线程在对内存进行操作时，其他线程都不
可以对这个内存地址进行操作，直到该线程完成操作,其他线程才能对该内存地址进行操作.
 同步具体方法 - Synchronized
 同步代码块
synchronized(对象){/得到对象的锁，才能操作同步代码
//需要被同步代码;
}
2. synchronized还可以放在方法声明中，表示整个方法 -为同步方法
public synchronized void m (String name){
//需要被同步的代码
}
 */

线程同步的实现方法

/*
使用多线程 模拟三个窗口同时售票
 */
public class SellTicket {
    public static void main(String[] args) {
        //会导致超卖 因为3个线程同时读取nums然而第一个读取还没有来的及卖票
//        SellTicket01 sellTicket01 = new SellTicket01();
//        SellTicket01 sellTicket02 = new SellTicket01();
//        SellTicket01 sellTicket03 = new SellTicket01();
//        sellTicket01.start();
//        sellTicket02.start();
//        sellTicket03.start();
        //同样会出现超卖
//        SellTicket02 sellTicket02 = new SellTicket02();
//        new Thread(sellTicket02).start();
//        new Thread(sellTicket02).start();
//        new Thread(sellTicket02).start();
        //三个线程操作的是同一个对象
        SellTicket03 sellTicket03 = new SellTicket03();
        new Thread(sellTicket03).start();
        new Thread(sellTicket03).start();
        new Thread(sellTicket03).start();

    }
}

//继承Tread
class SellTicket01 extends Thread {

    public static int nums = 100;

    public void run() {
        while (true) {

            if (nums <= 0) {
                System.out.println("票卖完了");
                break;
            }
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("窗口" + Thread.currentThread().getName() + "剩余" + (--nums));

        }
    }
}

//实现Runnable
class SellTicket02 implements Runnable {
    public static int nums = 100;

    @Override
    public void run() {
        while (true) {

            if (nums <= 0) {
                System.out.println("票卖完了");
                break;
            }
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("窗口" + Thread.currentThread().getName() + "剩余" + (--nums));

        }
    }
}
//Synchronized方法
class SellTicket03 implements Runnable {
    public static int nums = 100;
    private boolean loop = true;
    Object object = new Object();
    //1.同步静态方法的锁为当前类本身
    //2.在静态方法中实现同步代码使用
    //3.原因是静态方法比对象先创建 当类被加载到内存里 this针对的对象还没有被创建
    //4.所以方法使用 static 默认锁对象是当前类.class

public synchronized static void test1(){}
public static void test2(){
    synchronized (SellTicket03.class/*this这里使用this是错误的*/){

    }
}
    //1.这是同步方法 加在方法上
    //2.这是锁在this对象 就是当前对象
    //3.也可以在代码块加锁        一般使用这种方法
    //4.保证所有线程锁都是同一个对象
    /*在以下代码中 创建的线程对象不同 所以这个锁是无效的 因为每一个线程对象不同
    所以实际上有几个对象就会有几个锁 所以在实现Runnable接口时只创建一个对象创建三个线程只有一把锁
    class SellTicket01 extends Thread {
    synchronized(this){
            System.out.println("sss");}
    }
     */
    //5.默认对象就是this

    public /*synchronized*/ void sellFinish() {
        //同步方法同一时刻只有一个方法执行
        //这是代码块加锁
        //4.保证所有线程锁都是同一个对象
        synchronized (/*this*/object/*如果是new object()也不行因为每一个线程都会创建一个对象*/) {
            if (nums <= 0) {
                System.out.println("票卖完了");
                loop = false;
                return;
            }
        }
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("窗口" + Thread.currentThread().getName() + "剩余" + (--nums));
    }

    @Override
    public void run() {
//        while (true) {
//            sellFinish();
//            if (nums == 0) {
//                break;
//            }
//        }
        while (loop) {
            sellFinish();

        }
    }
}

锁

互斥锁

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

死锁

public class DeadLock {
    public static void main(String[] args) {
        //模拟一个死锁
        DeadLockDemo A = new DeadLockDemo(true);
        A.setName("A");
        DeadLockDemo B = new DeadLockDemo(false);
        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;
    }

    public void run() {
        /*
        1.如果flag true A线程得到o1对象锁再尝试获取o2 如果拿不到就会blocked
        2.如果flag false B线程得到o2对象锁再尝试获取o1 如果拿不到o1就会blocked
        3.就会出现一个死锁
         */
        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");

                }
            }
        }
    }
}

释放锁

/*
下面操作会释放锁
1.当前线程的同步方法、同步代码块执行结束
案例:上厕所，完事出来
2.当前线程在同步代码块、同步方法中遇到break、return。
案例:没有正常的完事,经理叫他修改bug，不得已出来
3.当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束
案例:没有正常的完事,发现忘带纸,不得已出来
4.当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停,并释放锁。
案例:没有正常完事，觉得需要酝酿下,所以出来等会再进去
 */
/*
下面操作不会释放锁
1.线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()
方法暂停当前线程的执行,不会释放锁
案例:上厕所，太困了,在坑位上眯了一会
2.线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起,
该线程不会释放锁。
提示:应尽量避免使用suspend() resume()来控制线程,方法不再推荐使用
 */

Homework

Homework1

/*
(1)在main方法中启动两个线程
(2)第1个线程循环随机打印100以内的整数
(3)直到第2个线程从键盘读取了“Q”命令。
 */
public class Homework01 {
    public static void main(String[] args) {
        Print print = new Print();
        Thread thread1 = new Thread(print);
        Q q = new Q(print);
        Thread thread2 = new Thread(q);
        thread1.start();
        thread2.start();
    }
}

class Print implements Runnable {
    private static boolean loop = true;

    public static void setLoop(boolean loop) {
        Print.loop = loop;
    }

    @Override
    public synchronized void run() {
        while (loop) {
            System.out.println(new Random().nextInt(100));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class Q implements /*KeyListener*/Runnable {
    private Print print;

    private Scanner scanner = new Scanner(System.in);//接收用户输入

    public Q(Print print) {
        this.print = print;
    }

//    @Override
//    public void keyTyped(KeyEvent e) {
//    }
//
//    @Override
//    public void keyPressed(KeyEvent e) {
//        if (e.getKeyCode() == KeyEvent.VK_Q) {
//            Print.setLoop(false);
//        }
//    }
//
//    @Override
//    public void keyReleased(KeyEvent e) {
//    }

    @Override
    public void run() {
        while (true) {
            char key = scanner.next().toUpperCase().charAt(0);
            if (key == 'Q') {
                Print.setLoop(false);
                System.out.println("Q线程退出");
                break;
            }
        }
    }
}

Homework2

/*
(1)有2个用户分别从同一个卡上取钱（总额:10000)
(2)每次都取1000,当余额不足时，就不能取款了
(3)不能出现超取现象=》线程同步问题.
*/
public class Homework02 {
    public static void main(String[] args) {
        Bank bank = new Bank();
        Thread thread1 = new Thread(bank);
        thread1.setName("客户1");
        Thread thread2 = new Thread(bank);
        thread2.setName("客户2");
        thread1.start();
        thread2.start();
    }
}

class Bank implements Runnable {
    public int card = 100000;//这里如果出现只有一个客户取钱建议扩大存款

    @Override
    public void run() {

        while (true) {
            synchronized (this) {
                if (card < 100) {
                    break;
                }

                card = card - 1000;
                System.out.println(Thread.currentThread().getName() + "取了1000还剩" + card);
            }
        }
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}