/*
同步函数:
同步函数使用的是哪一个锁呢?
函数需要被对象调用,那么函数都有一个所属对象引用,就是this
所以同步函数实使用的锁是this。
通过两个线程买票
一个线程在同步代码块中
一个线程在同步函数中
都在执行买票动作
发现还是出现不安全的情况
考虑两个前提:
1.必须是两个或者两个以上的线程(满足)
2.是不是用同一个锁(不满足)
如果同步函数被静态修饰后,使用是锁是什么?
通过验证,不是this,因为静态方法中也不可以定义this
静态进内存的时候内存中还没有建立对象,但一定有该类对应的字节码文件
类名.class 该对象的类型是Class
静态方法里面的锁不可能是this
静态的同步函数,使用的锁是该方法所在类的字节码文件对象, 类名.class
*/
class Ticket implements Runnable
{
private static int tick = 100;//静态共数据
boolean flag = true;
Object obj = new Object();
public void run()
{
if(flag)
{
while(true)
{
//synchronized(Ticket.class)//证明静态同步函数用是锁是 类名.class
synchronized(this)//该为this就安全了。证明了同步函数用的锁就是this
//synchronized(obj)
{
if(tick>0)
{
try{Thread.sleep(10);}catch(Exception e){}
System.out.println(Thread.currentThread().getName()+"...code..."+tick--);
}
}
}
}
else
while(true)
{
show();
}
}
//public static synchronized void show()//静态同步函数
public synchronized void show()//同步函数
{
if(tick>0)
{
try{Thread.sleep(10);}catch(Exception e){}
System.out.println(Thread.currentThread().getName()+"...show..."+tick--);
}
}
}
class ThreadDemo5
{
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 Single
{
private static final Single s = new Single();
private Single(){}
public static Single getInstance()
{
return s;
}
}
//懒汉式,特点:实例的延迟加载
多线程的访问的时候,存在安全问题
可以加同步来解决
用同步函数和同步代码块效率有点低下
用双重if语句判断来处理同步,可以解决效率问题
加同步的时候,使用的锁是该类所属是字节码文件对象
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 Test implements Runnable
{
private boolean flag;
Test(boolean flag)
{
this.flag = flag;
}
public void run()
{
if(flag)
{
synchronized(MyLock.locka)//同步中嵌套同步
{
System.out.println("if locka");//进程获得了a锁
synchronized(MyLock.lockb)//需要b锁,但是b锁被下面的进程占用了
{
System.out.println("if lockb");
}
}
}
else
{
synchronized(MyLock.lockb)//同步中嵌套同步
{
System.out.println("else lockb");//进程获得了b锁
synchronized(MyLock.locka)//需要a锁,但是a锁被上面的进程占用了,两个进程互不相让,导致死锁
{
System.out.println("else locka");
}
}
}
}
}
class MyLock
{
static Object locka = new Object();//定义成静态方便调用
static Object lockb = new Object();
}
class ThreadDemo7
{
public static void main(String[] args)
{
Thread t1 = new Thread(new Test(true));
Thread t2 = new Thread(new Test(false));
t1.start();
t2.start();
}
}
黑马程序员_多线程(下)
最新推荐文章于 2024-01-17 09:45:23 发布