} } }

    Java线程同步锁的选择

    添加时间:2013-5-15 点击量:

    　　在须要线程同步的时辰如何选择合适的线程锁？


    例：选择可以存入到常量池傍边的对象，String对象等　　



    public class SyncTest

    {

            private String name = name;

    public void method（String flag）

        {

                synchronized （name）

            {

                System.out.println（flag     + ， invoke method ....）;

                    try

                {

                    Thread.sleep（    1000）;

                }

                    catch （InterruptedException e）

                {

                    e.printStackTrace（）;

                }

            }

        }

        

            public static void main（String[] args）

        {

            SyncTest test1     = new SyncTest（）;

            

            SyncTest test2     = new SyncTest（）;

            

            MyThread1 myThread1     = new MyThread1（）;

            MyThread1 myThread2     = new MyThread1（）;

            myThread1.syncTest     = test1;

            myThread2.syncTest     = test1; 

            

            MyThread1 myThread3     = new MyThread1（）;

            MyThread1 myThread4     = new MyThread1（）;

            myThread3.syncTest     = test2;

            myThread4.syncTest     = test2;

            

            myThread1.start（）;

            myThread2.start（）;

            myThread3.start（）;

            myThread4.start（）;

            

        }

    

    

    }



    线程类：



    public class MyThread1 extends Thread

    {

        SyncTest syncTest;

        

        ＠Override

            public void run（）

        {

            syncTest.method（    this.getName（））;

        }

    

    }


    底本应当是要实现线程thread1和thread2同步，线程thread3和thread4同步的，但成果呢？


    倒是使得线程thread1、thread2、thread3、thread4同步了，很是愁闷。


    我推荐选用的同步锁对象：



    package com.rcx.thread;

    

    

    public class SyncTest

    {

            // 特别的instance变量，用于充当同步锁的对象

        private byte[] lock = new byte[0];

        

            public void method（String flag）

        {

                synchronized （lock）

            {

                System.out.println（flag     + ， invoke method f....）;

                    try

                {

                    Thread.sleep（    1000）;

                }

                    catch （InterruptedException e）

                {

                    e.printStackTrace（）;

                }

            }

        }

        

            public static void main（String[] args）

        {

            SyncTest test1     = new SyncTest（）;

            

            SyncTest test2     = new SyncTest（）;

            

            MyThread1 myThread1     = new MyThread1（）;

            MyThread1 myThread2     = new MyThread1（）;

            myThread1.syncTest     = test1;

            myThread2.syncTest     = test1; 

            

            MyThread1 myThread3     = new MyThread1（）;

            MyThread1 myThread4     = new MyThread1（）;

            myThread3.syncTest     = test2;

            myThread4.syncTest     = test2;

            

            myThread1.start（）;

            myThread2.start（）;

            myThread3.start（）;

            myThread4.start（）;

            

        }

    

    

    }


    推荐应用0长度的byte数组充当同步锁对象，不会产生很诧异的错误同时不会占用很大内存。


    分享到：