关于线程安全地懒汉式有以下几种方式：
/*** 实现线程安全的懒汉式*/
public class BankTest
{Bank b1 = null;Bank b2 = null;public static void main(String[] args){BankTest bb = new BankTest();Thread t1 = new Thread(){@Overridepublic void run(){bb.b1 = Bank.getInstance();}};Thread t2 = new Thread(){@Overridepublic 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对象。}
}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 finalprivate static final ReentrantLock ll = new ReentrantLock();@Overridepublic 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中。}}}
}线程（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。
线程的生命周期：
