Java线程安全

线程安全：

线程安全：

线程安全 – 加锁
注意：要想多个线程互斥住，就必须使用同一把锁(对象)！！！

加锁方式：

1. synchronized
2. Lock

 

synchronized

1. 同步代码块
2. 同步方法

 

同步代码块:

数据结构：

synchronized(锁对象){//自动上锁...想要互斥的代码...}//自动解锁

 

同步方法：

1. 成员同步方法
2. 静态同步方法

 

成员同步方法:

注意：锁对象 -> this

多个子线程时，调用的对象（this）不一样，则锁不住。

数据结构：

public synchronized void method(){//自动上锁...想要互斥的代码...}//自动解锁

 

静态同步方法：

注意：锁对象 -> 类.class

public static synchronized void method(){//自动上锁...想要互斥的代码...}//自动解锁

 
 

Lock:

			//锁对象Lock lock = new ReentrantLock();lock.lock();//手动上锁...想要互斥的代码...lock.unlock();//手动解锁

 

应用：

public class MyThread extends Thread{private static int allTicket = 1000;private static int curTicket = 0;private static Lock lock = new ReentrantLock();public MyThread(String name) {super(name);}@Overridepublic void run() {while(curTicket < allTicket){lock.lock();//手动上锁try {if(curTicket < allTicket){curTicket++;System.out.println("窗口" + Thread.currentThread().getName() + "正在销售第" + curTicket + "张票");}if(curTicket >= allTicket){System.out.println("窗口" +  Thread.currentThread().getName() + "票已经售完");}} catch (Exception e) {e.printStackTrace();} finally {lock.unlock();//手动解锁}}}}

public static void main(String[] args) {MyThread t1 = new MyThread("001");MyThread t2 = new MyThread("002");MyThread t3 = new MyThread("003");t1.start();t2.start();t3.start();}

 

 

单例模式：

该类的对象在整个项目中只创建一次（只实例化一次）。

 

懒汉式：

单例模式(懒汉式)不是线程安全的。

public class A {//声明对象名private static A a;private A(){}public static A getIntance(){//判断对象为空，再创建对象if(a == null){a = new A();}return a;}
}

public static void main(String[] args) {A a1 = A.getIntance();A a2 = A.getIntance();A a3 = A.getIntance();A a4 = A.getIntance();//地址都是一样的，则是一个对象System.out.println(a1);System.out.println(a2);System.out.println(a3);System.out.println(a4);}

 
 

饿汉式：

单例模式(饿汉式)是线程安全的。

public class A {//先创建对象private static A a = new A();private A(){}public static A getIntance(){return a;}public static void method(){System.out.println("用良心做教育");}
}

public static void main(String[] args) {A a1 = A.getIntance();A a2 = A.getIntance();A a3 = A.getIntance();A a4 = A.getIntance();System.out.println(a1);System.out.println(a2);System.out.println(a3);System.out.println(a4);}

 
 

缺点：如果只调用了类里的静态方法，没用到单例对象，就是浪费空间。

public static void main(String[] args) {A.method();}

 

 

枚举饿汉式：

枚举单例模式(饿汉式)是线程安全的。

public enum A {//public static final A a = new A();a;private A(){}public static A getIntance(){return a;}public static void method(){System.out.println("用良心做教育");}@Overridepublic String toString() {return String.valueOf(a.hashCode());}
}

public static void main(String[] args) {A a1 = A.getIntance();A a2 = A.getIntance();A a3 = A.getIntance();A a4 = A.getIntance();System.out.println(a1);System.out.println(a2);System.out.println(a3);System.out.println(a4);}

 
 

缺点：如果只调用了枚举里的静态方法，没用到单例对象，就是浪费空间。

public static void main(String[] args) {A.method();}

 
 

双重检验锁：

项目中使用的单例模式------->双重检验锁。

双重检验锁的单例模式是线程安全的。

volatile – 防止指令重排

 
创建对象的过程：

​ a.开辟空间 ----- new 对象() – 0x001

​ b.调用构造方法 – 初始化数据

​ c.将空间赋值给引用 – 类型 引用 = 0x001

 
创建对象的步骤：a/b/c 或 a/c/b
 
注意：如果创建对象的步骤是a/c/b，多线程的情况下可能会导致获取的属性为null
 
解决方案：使用volatile，防止指令重排，创建的步骤必须按照a/b/c

public class A {private static volatile A a;private A(){}public static A getIntance(){if(a == null){synchronized (A.class) {if(a == null){a = new A();}}}return a;}//	public static A getIntance(){
//		
//		if(a != null){
//			return a;
//		}
//		synchronized (A.class) {
//			if(a == null){
//				a = new A();
//			}
//		}
//		return a;
//	}
}

public static void main(String[] args) {A a1 = A.getIntance();A a2 = A.getIntance();A a3 = A.getIntance();A a4 = A.getIntance();System.out.println(a1);System.out.println(a2);System.out.println(a3);System.out.println(a4);}