本文小编为大家详细介绍“synchronized传统线程互斥技术怎么用”，内容详细，步骤清晰，细节处理妥当，希望这篇“synchronized传统线程互斥技术怎么用”文章能帮助大家解决疑惑，下面跟着小编的思路慢慢深入，一起来学习新知识吧。

我们提供的服务有：成都做网站、网站制作、成都外贸网站建设、微信公众号开发、网站优化、网站认证、萨嘎ssl等。为上千家企事业单位解决了网站和推广的问题。提供周到的售前咨询和贴心的售后服务，是有科学管理、有技术的萨嘎网站制作公司

在多个线程同时操作相同资源的时候，就会遇到并发的问题，如银行转账啊、售票系统啊等。为了避免这些问题的出现，我们可以使用 synchronized 关键字来解决，下面针对 synchronized 常见的用法做一个总结。首先写一个存在并发问题的程序，如下：

public class TraditionalThreadSynchronized {
    public static void main(String[] args) {
        //在静态方法中不能new内部类的实例对象
        //private Outputer outputer = new Outputer();
        new TraditionalThreadSynchronized().init();
    }
    private void init() {
        final Outputer outputer = new Outputer();
        //线程1打印：duoxiancheng
        new Thread(new Runnable() {         
            @Override
            public void run() {
                while(true) {
                    try {
                        Thread.sleep(5);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    outputer.output1("duoxiancheng");
                }
            }
        }).start();;
        //线程2打印：eson15
        new Thread(new Runnable() {         
            @Override
            public void run() {
                while(true) {
                    try {
                        Thread.sleep(5);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    outputer.output1("eson15");
                }
            }
        }).start();;
    }
    static class Outputer {
        //自定义一个字符串打印方法，一个个字符的打印
        public void output1(String name) {
            int len = name.length();
            for(int i = 0; i < len; i++) {
                System.out.print(name.charAt(i));
            }
            System.out.println("");     
        }       
    }
}

在内部类 Outputer 中定义了一个打印字符串的方法，一个字符一个字符的打印，这样比较容易直观的看出并发问题，因为字符顺序打乱了就说明出现问题了。然后在 init 方法中开启两个线程，一个线程打印 “duoxiancheng” ，另一个线程打印 “eson15”。看一下运行结果：

eson15duoxianche
ng
eson15
duoxiancheng
duoxiancheng
eson15
esduoxiancheng
on15
duoxiancheng

从输出的结果中可以看到，已经出现问题了，为了解决这个问题，可以使用 synchronized 同步代码块来对公共部分进行同步操作，但是需要给它一把锁，这把锁是一个对象，可以是任意一个对象，但是前提是，两个线程使用的必须是同一个对象锁才可以，这很好理解。那么下面在 output1() 方法中加入 synchronized 代码块：

static class Outputer {
    private String token = ""; //定义一个锁
    public void output1(String name) {
        synchronized(token) //任何一个对象都可以作为参数，但是该对象对于两个线程来说是同一个才行
        //如果用name就不行了，因为不同的线程进来name是不一样的，不是同一个name
        {
            int len = name.length();
            for(int i = 0; i < len; i++) {
                System.out.print(name.charAt(i));
            }
            System.out.println("");     
        }
    }
}

经过上面的改造，线程安全问题就基本解决了，但是还可以再往下引申，如果在方法上加 synchronized 关键字的话，那么这个同步锁是什么呢？我们在 Outputer 类中再写一个 output2() 方法：

static class Outputer {
    private String token = ""; //定义一个锁
    public void output1(String name) {
        synchronized(token) //任何一个对象都可以作为参数，但是该对象对于两个线程来说是同一个才行
        {
            int len = name.length();
            for(int i = 0; i < len; i++) {
                System.out.print(name.charAt(i));
            }
            System.out.println("");     
        }
    }   
    public synchronized void output2(String name) {
        int len = name.length();
        for(int i = 0; i < len; i++) {
            System.out.print(name.charAt(i));
        }
        System.out.println("");     
    }   
}

方法内部实现逻辑一模一样，唯一不同的就是 synchronized 加在了方法上，那么我们让 init() 方法中的两个线程中，一个调用 output1(Stringname) 方法，另一个调用 output2(Stringname) 方法，从结果中能看出，线程安全问题又出现了。产生问题的原因不难发现：现在两个方法都加了 synchronized，但是两个线程在调用两个不同的方法还是出现了问题，也就是说，还是各玩各的……那么问题就出在这个锁上，说明两者并没有使用同一把锁！
如果我们把 output1() 方法中 synchronized 中的 token 改成 this，再运行就没问题了，这说明一点：synchronized 关键字修饰方法的时候，同步锁是 this，即等效于代码块 synchronized(this){...}。
再继续往下引申，现在在 Outputer 类中再写一个静态方法 output3(Stringname)，并且也让 synchronized 去修饰这个静态方法。

static class Outputer {
    private String token = ""; //定义一个锁
    public void output1(String name) {
        synchronized(token) //任何一个对象都可以作为参数，但是该对象对于两个线程来说是同一个才行
        {
            int len = name.length();
            for(int i = 0; i < len; i++) {
                System.out.print(name.charAt(i));
            }
            System.out.println("");     
        }
    }   
    public static synchronized void output3(String name) {
        int len = name.length();
        for(int i = 0; i < len; i++) {
            System.out.print(name.charAt(i));
        }
        System.out.println("");     
        }   
    }
}

然后在 init() 方法中一个线程调用 output1() 方法，另一个线程调用 output3() 方法。毫无疑问，肯定又会出现线程安全问题。但是如何解决呢？因为 static 方法在类加载的时候就加载了，所以这个锁应该是类的字节码对象。那么将 token 改为 Outputer.class 就解决问题了，这说明一点：synchronized 关键字修饰 static 方法的时候，同步锁是该类的字节码对象，即等效于代码块 synchronized(classname.class){...}。
最后再总结一下：

• 同步代码块的锁是任意对象。只要不同的线程都执行同一个同步代码块的时候，这个锁随便设。

• 同步函数的锁是固定的 this。当需要和同步函数中的逻辑实行同步的时候，代码块中的锁必须为 this。

• 静态同步函数的锁是该函数所属类的字节码文件对象。该对象可以用 this.getClass() 方法获取，也可以使用 当前类名.class 表示。

读到这里，这篇“synchronized传统线程互斥技术怎么用”文章已经介绍完毕，想要掌握这篇文章的知识点还需要大家自己动手实践使用过才能领会，如果想了解更多相关内容的文章，欢迎关注创新互联行业资讯频道。

分享标题：synchronized传统线程互斥技术怎么用
本文URL：http://lswzjz.com/article/pcoeep.html