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的调用，释放对共享数据的锁定。

import java.util.concurrent.locks.ReentrantLock;

public class LockTest2
{
    public static void main(String[] args)
    {
        Window w1 = new Window("窗口一");
        Window w2 = new Window("窗口二");
        Window w3 = new Window("窗口三");
        w1.start();
        w2.start();
        w3.start();
    }
}

class Window extends Thread
{
    public Window()
    {

    }
    public Window(String name)
    {
        super(name);
    }

    private static int ticket = 100;
    //第一步，创建lock的实例，需要确保多个线程共用同一个实例，需要考虑将此对象声明为static final
    private static final ReentrantLock ll = new ReentrantLock();
    @Override
    public void run()
    {
        while(true)
        {
            try
            {
                //第二步，执行lock方法，锁定对共享资源的调用
                ll.lock();
                if(ticket > 0)
                {
                    try
                    {
                        Thread.sleep(10);
                    } catch (InterruptedException e)
                    {
                        e.getStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "卖出一张票，票号为" + ticket);
                    ticket--;
                }
                else
                {
                    break;
                }
            }
            finally
            {
                //第三步，unlock的调用，释放对共享数据的锁定
                ll.unlock();//防止break之后不关闭锁，要将其放在finally中。
            }
        }
    }
}

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。

        线程的生命周期：