首页 科技正文

线程的同步

admin 科技 2020-07-22 34 0

线程的同步

线程的安全问题

  • 多个线程执行的不确定性引起执行的效果的不稳定性
  • 多个线程对数据的共享,会造成操作的不完整性、会损坏数据(例如窗口买票问题,多个窗口对票数举行共享,会泛起两个窗口卖号码相同的票给差别的人)

通过同步机制解决线程安全问题

方式一:同步代码块

花样

synchronized(同步监视器){

    需要被同步的代码

    }

举例说明

class Thread implements Runnable{

    private Object obj = new Object();

    public void run() {
        //使用类工具充当锁
        synchronized(obj){
        .......
        }
    }
}

说明

  • 操作共享数据的代码即为需要被同步的代码
    • 不能多包罗代码,也不能少包罗代码
  • 共享数据:多个线程配合操作的变量
  • 同步监视器:俗称锁
    • 任何一个类的工具都可以来充当锁
    • 要求多个线程必须共用统一把锁
    • 在实现Runnable接口建立多线程的方式中,思量使用this充当同步监视器
    • 在继续Thread类建立多线程的方式中,慎用this来充当同步监视器,思量使用当前类来充当同步监视器

特点

  • 利益:解决线程的安全问题
  • 局限性:操作同步代码时,只能有一个线程介入,其他线程守候。相当于一个单线程的历程,效率低

代码实现

实现Runnable接口建立多线程的方式
/**
 * 建立三个窗口买票,票数100张:使用实现Runnable接口的方式实现的
 */
class WindowThread implements Runnable{

    private int ticket = 100;
    // private Object obj = new Object();

    public void run() {
        while (true) {
            //此时this:唯一的WindowThread工具
            synchronized(this){// 方式二:synchronized(obj){
                if (ticket > 0) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread(). getName() + ":" + "买票,票号为" + ticket);
                    ticket--;
                }else{
                    break;
                }
            }
        }
    }
}

public class Test1 {

    public static void main(String[] args) {
        WindowThread window = new WindowThread();

        Thread w1 = new Thread(window);
        Thread w2 = new Thread(window);
        Thread w3 = new Thread(window);

        w1.setName("窗口1");
        w1.start();
        w2.setName("窗口2");
        w2.start();
        w3.setName("窗口3");
        w3.start();
    }
}
继续Thread类建立多线程的方式
class Window extends Thread {
    // 人人公用数据,只有100张票
    private static int ticket = 100;
    private static Object obj = new Object();
    public void run() {
        while (true) {
            //方式二
            synchronized(Window.class){
                // 方式一:synchronized(obj){
                //synchronized(this)错误的,此时this代表着三个工具
                if(ticket > 0){
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(getName() + ":" + "买票,票号为" + ticket);
                    ticket--;
                }else{
                    break;
                }
            }

        }
    }
}

public class Test2 {
    public static void main(String[] args) {
        Window w1 = new Window();
        Window w2 = new Window();
        Window w3 = new Window();

        w1.setName("窗口1");
        w2.setName("窗口2");
        w3.setName("窗口3");

        w1.start();
        w2.start();
        w3.start();
    }
}

同步方式

若是操作共享数据的代码完整的声明在一个方式中,就可以将此方式声明同步的

花样

行使synchronized 修饰方式

public synchronized void XXX(){

}

public static synchronized void XXX(){

}

说明

  • synchronized修饰方式时锁定的是挪用该方式的工具
  • 同步方式仍然涉及到同步监视器,只是不需要我们显示的声明
  • 非静态的同步方式,同步监视器是this
  • 静态的同步方式,同步监视器是当前类自己(Window.class)

代码实现

实现Runnable接口建立多线程的方式

非静态同步方式,挪用this

class WindowThread3 implements Runnable{

    private int ticket = 100;
    private static boolean isFlag = true;
    // private Object obj = new Object();

    public void run() {
        while (isFlag) {
            show();
        }
    }

    public synchronized void show(){//同步监视器:this
        if (ticket > 0) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread(). getName() + ":" + "买票,票号为" + ticket);
            ticket--;
        }else{
            isFlag = false;
        }
    }
}

public class Test3 {
    public static void main(String[] args) {
        WindowThread3 window = new WindowThread3();

        Thread w1 = new Thread(window);
        Thread w2 = new Thread(window);
        Thread w3 = new Thread(window);

        w1.setName("窗口1");
        w1.start();
        w2.setName("窗口2");
        w2.start();
        w3.setName("窗口3");
        w3.start();
    }
}
继续Thread类建立多线程的方式

静态同步方式,挪用当前类自己

class Window4 extends Thread{
    private static int ticket = 100;
    private static boolean isFlag = true;

    @Override
    public void run() {
        while(isFlag){
            show();
        }
    }

    public static synchronized void show(){
        //同步监视器:Window.class
        if(ticket > 0){
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread(). getName() + ":" + "买票,票号为" + ticket);
            ticket--;
        }else{
            isFlag = false;
        }
    }
}

public class Test4 {
    public static void main(String[] args) {
        Window4 w1 = new Window4();
        Window4 w2 = new Window4();
        Window4 w3 = new Window4();

        w1.setName("窗口1");
        w2.setName("窗口2");
        w3.setName("窗口3");

        w1.start();
        w2.start();
        w3.start();
    }
}

通过Lock(锁)解决线程安全问题

步骤

  1. 实例化ReentrantLock

    private ReentrantLock lock = new ReentrantLock(true);

    • true代表公正
    • 不填默以为false
  2. 挪用锁的方式

    在可能会泛起安全问题代码前挪用Lock接口中的方式Lock获取锁
    lock.lock();

  3. 挪用解锁的方式

    lock.unlock();

注重:其中挪用lock()方式和unlock()方式时要用try()finally()包住

代码实现

class Window5 implements Runnable {

    private int ticket = 100;

    //1.实例化ReentrantLock
    private ReentrantLock lock = new ReentrantLock(true);

    public void run() {
        while (true) {
            try{
                //2.挪用锁定的方式:lock()
                lock.lock();

                if (ticket > 0) {

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

                    System.out.println(Thread.currentThread().getName() +  "卖票" + ":" + "票号为" + ticket);
                    ticket--;
                }else{
                    break;
                }
            }finally{
                //3.挪用解锁的方式:unlock()
                lock.unlock();
            }
        }

    }

}

public class Test5 {
    public static void main(String[] args) {
        Window5 window = new Window5();

        Thread t1 = new Thread(window);
        Thread t2 = new Thread(window);
        Thread t3 = new Thread(window);

        t1.setName("窗口1:");
        t2.setName("窗口2:");
        t3.setName("窗口3:");

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

synchronized和Lock的异同

  • synchronized机制在执行完响应的代码逻辑后自动释放同步监视器
  • Lock需要手动的启动同步(lock),同时竣事同步也需要手动的实现(unlock)

  • 都可以解决线程安全问题

释放锁与不释放锁的操作

释放锁的操作

  • 当前线程的同步方式、同步代码块执行竣事
  • 当前线程在同步代码块、同步方式中泛起了未处理的Error或Exception,导致异常竣事
  • 当前线程在同步代码块、同步方式中遇到了break、return终止了该代码块、方式的继续执行
  • 当前线程在同步代码块、同步方式中执行了线程工具的wait()方式,当前线程暂停,并释放锁

不释放锁的操作

  • 线程在执行同步代码块或同步方式时,程序挪用了Thread.sleep()或Thread.yield()方式暂停当前线程的执行
  • 线程在执行同步代码块时,其他线程挪用了该线程的suspend()方式将该线程挂起,该线程不会释放锁(同步监视器)
    • 只管制止使用suspend()(挂起)和resume()(继续执行)来控制线程

使用顺序

Lock--->同步代码块--->同步方式

死锁

  • 差别线程划分占用对方需要的同步资源不放弃,都在守候对方放弃自己需要的同步资源,就形成了线程的死锁
  • 泛起死锁后,不会泛起异常,不会泛起提醒,只是所有的线程都处于阻塞状态,无法继续
  • 使用同步时,制止泛起死锁
  • 制止
    • 专门的算法
    • 只管削减同步资源的界说
    • 只管制止嵌套同步
,

欧博开户网址

欢迎进入欧博开户网址(Allbet Gaming):www.aLLbetgame.us,欧博网址开放会员注册、代理开户、电脑客户端下载、苹果安卓下载等业务。

版权声明

本文仅代表作者观点,
不代表本站Allbet的立场。
本文系作者授权发表,未经许可,不得转载。

评论