192.168.1.1-路由器设置 | 192.168.0.1-无线路由器设置

多线程同步基础知识:实现和继承方式

发布时间:2015-10-03 08:43

 实现方式和继承方式的区别:

实现方式好处避免了但继承的局限性(不能继承其他类,只能继承Thread类)
定义线程时,建议使用实现方式。
两种方式区别:
继承Thread:线程代码存放Thread子类的run方法中
实现Runnable:线程代码存放接口子类的run方法中
 
同步的前提:
1,必须要有两个或者两个以上的线程。
2,必须是多个线程使用同一个锁(同一个对象)。
 
必须保证同步中只能有一个线程在运行。
 
如何判断程序是否有安全问题:
1,明确哪些代码是多线程运行代码。
2,明确共享数据。
3,明确多线程运行代码中哪些语句是操作共享数据的。
 
同步的两种表现形式:同步代码块和同步函数
同步代码块
 
Object obj = new Object();
 
synchronized(obj)
            {
               //todo
            }
 
同步函数(使用的锁是this)
同步函数被静态修饰后使用的锁不再是this,因为静态方法中不可以有this,
静态的同步方法使用的锁是该方法所在类的字节码文件对象。 类名.class
 
public synchronized void add(int n)
    {
        
        
    }
 
    public static synchronized void show()
    {
         
    }
同步代码块和同步函数要使用同一把锁需要让同步代码块的锁设为this或者类名.class
 
多线程单例最好写成饿汉式(函数里面只有一句话)
 
class Single
{
    private static final Single s = new Single();
    private Single(){}
    public static Single getInstance()
    {
        return s;
    }
}
 
懒汉式的延时加载多线程访问时会出现安全问题,同步锁是该类的字节码对象
 
class Single
{
    private static Single s = null;
    private Single(){}
 
 
    public static  Single getInstance()
    {
        if(s==null)
        {
            synchronized(Single.class)
            {
                if(s==null)
                    //--->A;
                    s = new Single();
            }
        }
        return s;
    }
}
 
 
同步弊端死锁-同步嵌套,锁不一样
 
/*
死锁。
同步中嵌套同步。
 
*/
 
class Ticket implements Runnable
{
    private  int tick = 1000;
    Object obj = new Object();
    boolean flag = true;
    public  void run()
    {
        if(flag)
        {
            while(true)
            {
                synchronized(obj)
                {
                    show();
                }
            }
        }
        else
            while(true)
                show();
    }
    public synchronized void show()//this
    {
        synchronized(obj)
        {
            if(tick>0)
            {
                try{Thread.sleep(10);}catch(Exception e){}
                System.out.println(Thread.currentThread().getName()+"....code : "+ tick--);
            }
        }
    }
}
 
 
class  DeadLockDemo
{
    public static void main(String[] args) 
    {
 
        Ticket t = new Ticket();
 
        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);
        t1.start();
        try{Thread.sleep(10);}catch(Exception e){}
        t.flag = false;
        t2.start();
 
 
    }
}
 
class Test implements Runnable
{
    private boolean flag;
    Test(boolean flag)
    {
        this.flag = flag;
    }
 
    public void run()
    {
        if(flag)
        {
            while(true)
            {
                synchronized(MyLock.locka)
                {
                    System.out.println(Thread.currentThread().getName()+"...if locka ");
                    synchronized(MyLock.lockb)
                    {
                        System.out.println(Thread.currentThread().getName()+"..if lockb");                    
                    }
                }
            }
        }
        else
        {
            while(true)
            {
                synchronized(MyLock.lockb)
                {
                    System.out.println(Thread.currentThread().getName()+"..else lockb");
                    synchronized(MyLock.locka)
                    {
                        System.out.println(Thread.currentThread().getName()+".....else locka");
                    }
                }
            }
        }
    }
}
 
 
class MyLock
{
    static Object locka = new Object();
    static Object lockb = new Object();
}
 
class  DeadLockTest
{
    public static void main(String[] args) 
    {
        Thread t1 = new Thread(new Test(true));
        Thread t2 = new Thread(new Test(false));
        t1.start();
        t2.start();
    }
}
关于我们 - RSS地图 - 最近更新 - 友情链接 - 网站地图 - 版权声明