day37 线程

news2024/10/7 10:10:24

一、线程安全

二、多线程并发的安全问题

当多个线程并发操作同一临界资源由于线程切换实际不确定导致操作顺序出现混乱

产生的程序bug 严重时出现系统瘫痪

临界资源：操作该资源的完整流程同一时间只能被单一线程操作的资源

多线程并发会出现的各种问题、

如图会出现的各种异常问题

1. 数组长度不够
2. 数组下标越界
3. 0元素过多

两个线程可能会同时读取和修改c.array的长度，从而导致数组长度不一致，进而导致越界异常。在第一个线程使用Arrays.copyOf方法增加数组长度时，第二个线程可能会在此同时读取数组长度，然后在第一个线程修改完成之前，第二个线程又对数组进行了操作，从而导致长度不一致，然后就会出现越界异常。

public class Test {
    public static void main(String[] args) throws InterruptedException {
        Coo c = new Coo();

        Thread t1 = new Thread() {
            @Override
            public void run() {
               synchronized (c){
                  // System.out.println("this1:"+this);
                   for (int i = 0; i < 100; i++) {
                       c.array = Arrays.copyOf(c.array, c.array.length + 1);
                       c.array[c.array.length-1] = i;
                   }
               }
            }
        };

        Thread t2 = new Thread() {
            @Override
            public void run() {
               synchronized (c){
                  // System.out.println("this:"+this);
                   for (int i = 100; i < 200; i++) {
                       c.array = Arrays.copyOf(c.array, c.array.length + 1);
                       c.array[c.array.length-1] = i;
                   }
               }
            }
        };

        t1.start();
        t2.start();

        /**
         * 多执行几次，检查程序可能存在的问题，并尝试分析为什么会出现这些情况，以及解决方案
         *
         *  1. 数组长度不够
         *  2. 数组下标越界
         *  3. 0元素过多
         */
        //Thread.sleep(1000); //阻塞1秒钟，等待上面两个线程干完活再输出
        t1.join();
        t2.join();
        System.out.println(c.array.length);
        System.out.println(Arrays.toString(c.array));
    }
}

当一个方法使用synchronized修饰，这个方法称之为同步方法，多个线程不能同时在方法内部执行

同步与异步的区别总结来说，同步和异步的区别：请求发出后，是否需要等待结果，才能继续执行其他操作

同步代码块使用的时候需要注意的是同步监视器对象的选择（重点）

1：对象可以是引用数据类型的对象

2：必须保证多个线程看到的对象是同一个

3：在方法上使用synchronized ，那么同步监视器对象就是this,不能自行指定，是默认的

4：静态方法上若使用synchronized，则该方法一定具有同步效果
5注意：静态方法上执行的同步监视器对象不能使用this,而是当前类的类对象

静态方法中使用同步代码块的锁对象应当是当前类的对象，格式：类名.class

* 类对象：
* Class类的一个实例，JVM加载一个类的时候就会实例化一个Class的实例并用于保存加载这个类的
* 相关信息，因此每个被加载的类都是有且仅有一个Class的实例与之对应，静态方法的锁对象就是它
* 类对象会在后续的反射知识中详细说明

有限的缩小同步范围可以在保证并发安全的前提下保证效率

互斥锁

当使用多个Synchronized锁定多个代码片段并且指定的所的对象相同时这些代码片段就是互斥的

多个线程不能同时调用他们

package com.oracle.day37;

public class SynchronizedDemo4 {
    public static void main(String[] args) {


    Doo d = new Doo();

//    Thread t1 = new Thread(() -> d.methodA());
        Thread t1 = new Thread(){
            @Override
            public void run() {
                d.methodA();
                d.methodB();
            }
        };
//    Thread t2 = new Thread(() -> d.methodB());
        Thread t2 = new Thread(){
            @Override
            public void run() {
                d.methodA();
                d.methodB();
            }
        };

    t1.start();
    t2.start();
    }
}
class Doo{
    public synchronized void methodA()  {
        Thread t = Thread.currentThread();
        System.out.println(t.getName()+"正在执行方法A");

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

        System.out.println(t.getName()+"方法A执行完毕");
    }
    public static void methodB() {
        Thread t = Thread.currentThread();
        System.out.println(t.getName()+"正在执行方法B");

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

        System.out.println(t.getName()+"方法B执行完毕");
    }
}

死锁

在没有释放一把锁的同时调用了另一把锁

锁中放锁

线程的通讯

每一个线程都是独立运行的状态但需要多个线程完成同一件事

需要多个线程有规律地运行

线程之间就需要通信，告知对方自己的状态

概念等待队列唤醒

相关方法：

void join（）线程进入等待状态等待另一条线程执行完毕然后继续执行

void wait（）释放锁标记，进入等待队列

void wait（long time）释放锁进入等待队列等待多长时间

void notify（）唤醒线程

void notifyAll（）唤醒全部线程

package com.oracle.day37.thread;

public class ThreadDemo2 {
    public static Object o = new Object();

    public static void main(String[] args) {
        Thread t1 = new Thread(){
            @Override
            public void run() {
               synchronized(o){
                   for (int i = 1; i <= 26; i++) {
                       System.out.println(i);
                       try {
                           o.wait();
                       } catch (InterruptedException e) {
                           e.printStackTrace();
                       }
                       o.notify();
                   }
               }
            }
        };

        Thread t2 = new Thread(){
            @Override
            public void run() {
               synchronized (o){
                   for (int i = 'A'; i <= 'Z'; i++) {
                       System.out.println((char)i);
                       o.notify();
                       try {
                           o.wait();
                       } catch (InterruptedException e) {
                           e.printStackTrace();
                       }
                   }
               }
            }
        };
        t1.start();
        t2.start();
    }
}

锁的几种形式

①：方法中添加synchronized修饰符

②：使用同步代码块

synchronized（）{}；
* synchronized()可以添加
* this
* Object o
* Shop.class
* "abc"
③：Lock接口

要使用Lock接口，必须在线程中创建并获得Lock对象，然后在需要进行线程同步的代码块中使用lock()方法获取锁，使用unlock()方法释放锁。在多线程环境下，每个线程都必须单独创建自己的Lock对象，并进行锁定和解锁。这种方式可以保证每个线程都能够获取到自己的锁，从而在并发访问时保证线程安全性。
class BuyTicketMethod extends Thread{
    private static Integer M = 20;
    private final Lock lock = new ReentrantLock();
    @Override
    public  void run() {
        for (int i = 0; i < 10; i++) {
            lock.lock();
            try {
                if (M > 0){
                    System.out.println("您在"+Thread.currentThread().getName()+"购买成功剩余票是"+(--M)+"张");
                }
            } finally {
                lock.unlock();

            }

        }

    }
}