多线程练习---交替打印/多线程下安全实现懒汉式单例模式

5月27

使用双重检查DCL实现多线程下懒汉式单例模式：

package com.itheima.bookcurrentment;

import lombok.SneakyThrows;
import java.util.concurrent.TimeUnit;

public class MyObject {
    private volatile static MyObject myObject;
    private MyObject(){}

    public static MyObject getInstance() throws InterruptedException {
        if(myObject!=null){
        }else {
            TimeUnit.SECONDS.sleep(1);
            synchronized (MyObject.class){
                if(myObject==null){
                    myObject=new MyObject();
                }
            }
        }
        return myObject;
    }
}
class myThread extends Thread{

    @SneakyThrows
    @Override
    public void run() {
        System.out.println(MyObject.getInstance().hashCode());
    }
}

测试类：

package com.itheima.bookcurrentment;

import com.sun.deploy.net.proxy.ProxyUnavailableException;
import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;

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

    Thread t1=new myThread();
        Thread t2=new myThread();
        Thread t3=new myThread();
    t1.start();
    t2.start();
    t3.start();
    }
}

打印结果：
802393921
802393921
802393921

使用静态内部类实现多线程下懒汉式单例模式：

package com.itheima.bookcurrentment;

import lombok.SneakyThrows;
import java.util.concurrent.TimeUnit;

class MyObject {
   private static class MyObjectHandler{
       private static MyObject myObject=new MyObject();
   }
   private MyObject(){}

   public static MyObject getInstance(){
       return MyObjectHandler.myObject;
   }

}

class myThread extends Thread{
    @Override
    public void run() {
        System.out.println(MyObject.getInstance().hashCode());
    }
}

package com.itheima.bookcurrentment;

import com.itheima.bookcurrentment.myThread;

public class StaticSingleton {
    public static void main(String[] args) {
        Thread t1=new myThread();
        Thread t2=new myThread();
        Thread t3=new myThread();
        t1.start();
        t2.start();
        t3.start();
    }
}

打印结果：
878933552
878933552
878933552

用ReentrantLock类的await()和single()方法实现交替打印：
1）写一个打印的方法：

package com.itheima.bookcurrentment;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class MyService {
    private ReentrantLock lock=new ReentrantLock();
    private Condition condition=lock.newCondition();
    private boolean hasValue=false;

    public  void set(){
        try{
            lock.lock();
            while (hasValue==true){
                condition.await();
            }
            System.out.println("打印00");
            hasValue=true;
            condition.signal();

        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
         lock.unlock();
        }
    }
    public void get(){
        try{
          lock.lock();
          while (hasValue==false){
              condition.await();
          }
            System.out.println("打印11");
          hasValue=false;
          condition.signal();
        }catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
     lock.unlock();
        }

    }
}

2）写两个线程调用该打印方法

package com.itheima.bookcurrentment;

public class MyThreadA extends Thread{
    private MyService myService;
    public MyThreadA(MyService myService){
        this.myService=myService;
    }

    @Override
    public void run() {
        for(int i=0;i<Integer.MAX_VALUE;i++){
            myService.set();
        }
    }
}

package com.itheima.bookcurrentment;

public class MyThreadB extends Thread{
    private MyService myService;
    public MyThreadB(MyService myService){
        this.myService=myService;
    }
    @Override
    public void run() {
        for(int i=0;i<Integer.MAX_VALUE;i++){
            myService.get();
        }
    }
}

3）写一个测试类，实例化两个线程，并启动，查看打印结果

package com.itheima.bookcurrentment;

public class MyTest {
    public static void main(String[] args) {
        MyService myService=new MyService();
        MyThreadA a=new MyThreadA(myService);
        a.start();

        MyThreadB b=new MyThreadB(myService);
        b.start();
    }
}

打印结果：
打印11
打印00
打印11
打印00
打印11
打印00
打印11
打印00
打印11
打印00
打印11
打印00
打印11