同步方法解决线程的安全问题
@[toc]
处理实现Runnable的线程安全问题
- 如果操作共享数据的代码完整的声明在一个方法中，我们可以将此方法声明为同步的
（ps：相当于把操作共享数据的部分放在另外一个方法之中，再把这个方法写成synchronized的，然后run方法去调用这个方法）
代码部分：
package com.jsm.java2;
//这里用实现Runnable接口的方式做之前抢票的例题
public class WindowTest2 {
public static void main(String[] args) {
Window2 w1 = new Window2();
Thread t1 = new Thread(w1);
Thread t2 = new Thread(w1);
Thread t3 = new Thread(w1);
t1.start();
t2.start();
t3.start();
}
}
class Window2 implements Runnable{
private int num =100;//未加static，因为此时三个线程共用同一个num，此时只造了一个对象
@Override
public void run() {
while (true){
show();
if (num==0){
break;//不判断的话线程需要手动关闭
}
}
}
public synchronized void show(){
if (num>0){
System.out.println(Thread.currentThread().getName()+"卖出的票号为："+num);
num--;
}
}
}处理继承Thread类的线程安全问题
- 该种情况不能像上面那样直接另外写一个synchronized方法来调用，因为锁的问题，这钟情况下建了多个对象锁不唯一
- 这种情况下考虑把方法写成静态的
package com.jsm.java2;
/*
同步方法处理继承Thread类的线程安全问题
*/
class WindowTest1 {
public static void main(String[] args) {
Window3 w1 = new Window3();
Window3 w2 = new Window3();
Window3 w3 = new Window3();
w1.start();
w2.start();
w3.start();
}
}
class Window3 extends Thread{
private static int num =100;
@Override
public void run() {
while (num>0){
show();
if (num == 0) {
break;
}
}
}
private static synchronized void show(){//同步监视器：Window3.class
if (num>0){
System.out.println(Thread.currentThread().getName()+":卖票，票号为："+num);
num--;
}
}
}总结
- 同步方法仍然涉及到同步监视器，只是不需要显式的声明
- 非静态的同步方法，同步监视器是：this
- 静态的同步方法，同步监视器是：当前类本身
使用同步机制将单例模式中的懒汉式改写为线程安全的
在文章：Java设计模式之单例设计模式
原代码：
package day2;
//单例设计模式的懒汉式实现
public class SingletonTest2 {
}
class Order{
//1.私有化类的构造器
private Order(){
}
//2.声明当前类对象，没有初始化
//4.此对象也必须声明为static的
private static Order o1=null;
//3.声明public 、static的返回当前类的方法
public static Order getO1(){
if (o1==null){
o1= new Order();
}
return o1;
}
}
//ps：懒汉式暂时还存在线程安全问题，后面多线程时，可修复线程安全问题原因：就是调用get01方法的时候，第一个线程调用的时候判断o1为null，所以就正打算去new对象，结果这时候发生堵塞或者cpu执行别的任务了，另一个线程进来也判断为空了，就又去准备new一个对象，相当于先后被两次赋值过。
使用同步机制将单例模式中的懒汉式改写为线程安全的
package com.jsm.java1;
//使用同步机制将单例模式中的懒汉式改写为线程安全的
public class BankTest {
}
class Order{
private Order(){
}
private static Order o1=null;
//方式一：同步方法
public synchronized static Order get01(){
if (o1==null){
o1=new Order();
}
return o1;
}
//方法二：同步代码，但是效率稍差，因为除了第一次线程进去需要new一个对象，后面线程进去其实都不需要new一个对象
/* public static Order get01(){
synchronized (Order.class) {
if (o1==null){
o1=new Order();
}
return o1;
}
}
*/
}此时的锁：静态的同步方法，同步监视器是：当前类本身，所以是Order.class
PS：方法二形象举例讲解：就好像买新发布的鞋一样，只有一双，但是一次只能进去一个人，大家不知道只有一双，而且假设进去的人出来后没法和等待的人接触，然后进去第一个人买到了，走了，又进去第二个人，然后说卖完了，走了，然后又进去第三个人，又说买完了，又走了，以此类推，后面每个人都进去走一次，后面的人的等待就是浪费时间。
代码更改为：
public static Order get01() {
if (o1 == null) {
synchronized (Order.class) {
if (o1 == null) {
o1 = new Order();
}
}
}
return o1;
}这样的效率更高的原因：在进入操作共享数据的代码块之前就对是否o1==null进行一次判断，可能着时候有多个线程挤进来了，但是还不涉及对共享数据进行操作，所以进行判断之后就看谁运气好抢到了位置进到了对共享数据的操作部分，举个例子，一下子有ABC三个线程进入了第一次if判断语句，可能产生堵塞，三个都判断为null，所以都进来了，但是遇见了synchronized，只能ABC三个抢位置看谁先进入，这时候假设B进入了，然后B判断为空，new了一个对象，走了，后面两个又重新进来，重新判断，都不为空，然后都出去了，但是ABC之后的又线程又进来，这时候第一层if语句就已经把所有线程记之门外了，所以就不用再进去判断，直接return o1出去了，所以这样更加提高了效率。
