Java,多线程,线程安全的懒汉式、死锁、ReentrantLock的使用以及一些知识点补充

关于线程安全地懒汉式有以下几种方式:

/**
 * 实现线程安全的懒汉式
 */
public class BankTest
{
    Bank b1 = null;
    Bank b2 = null;
    public static void main(String[] args)
    {
        BankTest bb = new BankTest();
        Thread t1 = new Thread(){
            @Override
            public void run()
            {
                bb.b1 = Bank.getInstance();
            }
        };
        Thread t2 = new Thread(){
            @Override
            public void run()
            {
                bb.b2 = Bank.getInstance();
            }
        };


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


        try
        {
            t1.join();
        } catch (InterruptedException e)
        {
            e.getStackTrace();
        }
        try
        {
            t2.join();
        } catch (InterruptedException e)
        {
            e.getStackTrace();
        }
        System.out.println(bb.b1);
        System.out.println(bb.b2);
        System.out.println(bb.b1 == bb.b2);
    }
}


//          方式一:同步方法
//class Bank
//{
//    private Bank(){};//私有化构造器
//    private static Bank instance = null;//私有的类变量
//    //实现线程安全的方式一
//    public static synchronized Bank getInstance()//此时的同步监视器为Bank.class
//    {
//        if(instance == null)//只有当instance是非空指针时,才会创建新的对象
//        {
//            try
//            {
//                Thread.sleep(100);
//            } catch (InterruptedException e)
//            {
//                e.getStackTrace();
//            }
//            instance = new Bank();
//        }
//        return instance;
//    }
//}


//         方式二:同步代码块
//class Bank
//{
//    private Bank(){};//私有化构造器
//    private static Bank instance = null;//私有的类变量
//    //实现线程安全的方式一
//    public static Bank getInstance()
//    {
//        synchronized (Bank.class)
//        {
//            if(instance == null)//只有当instance是非空指针时,才会创建新的对象
//            {
//                try
//                {
//                    Thread.sleep(100);
//                } catch (InterruptedException e)
//                {
//                    e.getStackTrace();
//                }
//                instance = new Bank();
//            }
//            return instance;
//        }
//    }
//}


//          方式三:加了一层if,相较于方式一和方式二效率更高
//为了避免指令重排,需要将instance声明为volatile。
class Bank
{
    private Bank(){};//私有化构造器
    //私有的类变量
    private static volatile Bank instance = null;
    //实现线程安全的方式一
    public static Bank getInstance()
    {
        if(instance == null)
        {
            synchronized (Bank.class)
            {
                if (instance == null)//只有当instance是非空指针时,才会创建新的对象
                {
                    try
                    {
                        Thread.sleep(100);
                    } catch (InterruptedException e)
                    {
                        e.getStackTrace();
                    }
                    instance = new Bank();
                }


            }
        }
        return instance;//让较后的线程可以更快地拿到instance对象。
    }
}
方式三中,如果没有volatile关键字,可能会出现指令重排,当对象还未完全创建,但是已经提前return了。后面的线程判断时,未完全创建的对象也被判断为非空,对象的创建就会失败。从jdk2开始,分配空间、初始化、调用构造器会在线程的工作存储区一次性完成,然后复制到主存储区。但是需要volatile关键字,避免指令重排。
所以,要在instance的声明处加上volatile关键字。
死锁:
不同的线程分别占用对方的同步资源不放弃,都在等待对方放弃自己需要的同步资源,就形成了线程的死锁。
一旦出现死锁,整个程序既不会发生异常,也不会给出任何提示,只是所有线程处于阻塞状态,无法继续。
诱发死锁的原因:
①互斥条件
②占用且等待
③不可抢夺(或不可抢占)
④循环等待(一直等待)
以上四个条件同时出现就会触发死锁。
解决死锁:
死锁一旦出现,基本很难人为干预,只能尽量规避。可以考虑打破上面的诱发条件:
针对条件①:互斥基本无法被破坏。因为线程需要通过互斥解决安全问题。
针对条件②:可以考虑一次性申请所有所需的资源,就不存在等待的问题。
针对条件③:占用部分资源的线程在进一步申请其他资源时,如果申请不到,就主动释放掉已经占用的资源。
针对条件④:可以将资源改为线性顺序。申请资源时,先申请序号较小的,这样避免循环等待问题。
除了使用synchronized同步机制处理线程安全的问题之外,还可以使用jdk5.0提供的Lock锁的方式。
步骤:
第一步,创建lock的实例,需要确保多个线程共用同一个实例,需要考虑将此对象声明为static final。
第二步,执行lock方法,锁定对共享资源的调用。
第三步,unlock的调用,释放对共享数据的锁定。
synchronized同步的方式与Lock的对比:
synchronized不管是同步代码块还是同步方法,都需要在结束一对{}之后,释放对同步监视器的调用。
Lock是通过两个方法控制需要被同步的代码,更灵活一些。
Lock作为接口,提供了多种实现类,适合更多更复杂的场景,效率更高。
Thread类的常用方法和生命周期

线程(Thread)的常用结构:

·public  Thread( ) :分配一个新的线程对象。

·public  Thread(String  name) :分配一个指定名字的新的线程对象。

·public  Thread(Runnable  target) :分配一个指定创建线程的目标对象(实现了Runnable接口的类的对象,并且该对象实现了Runnable中的run方法)。

·public  Thread(Runnable  target) :分配一个指定创建线程的目标对象并指定名字。

        线程(Thread)中的常用方法:

·start( ) :①启动线程。②调用线程的run( )方法。

·run( ) :将线程要执行的操作,声明在run中。

·currentThread( ) :获取当前执行代码对应的线程。

·getName( ) :获取线程的名称。

·setName( ) :设置线程名。

·sleep( ) :(静态方法)调用时,可以使得当前线程睡眠指定的毫秒数。

·yield( ) :(静态方法)一旦执行此方法,就释放CPU的执行权。

·join( ) :在线程a中通过线程b调用join( ),意味着线程a进入阻塞状态,直到线程b执行结束,线程a才结束阻塞状态,继续执行。

·isAlive( ) :判断当前线程是否存活。

过时方法:

①stop( ) :强制结束一个线程的执行,直接让其进入死亡状态。(不建议使用)

suspend( ) / resume( ) :暂停 / 恢复  线程的执行。(可能会造成死锁,不建议使用)

        线程的优先级:

getPriority( ) :获取线程的优先级。

setPriority( ) :设置线程的优先级。范围:[1,10]。

Thread类内部声明的三个与优先级有关的常量:

——MAX_PRIORITY(10) :最高优先级。

——MIN_PRIORITY(1) :最低优先级。

——NORM_PRIORITY(5):普通优先级,默认情况下main线程具有普通优先级。

注:优先级高并非先执行,而是有更大的概率使用CPU。

        线程的生命周期:

Java,多线程,线程安全的懒汉式、死锁、ReentrantLock的使用以及一些知识点补充_第1张图片

你可能感兴趣的:(java)