Java——多线程安全问题



静态代码块中没有this

/*

 * 线程安全问题产生的原因：

 * 1.多个线程操作共享的数据

 * 2.操作共享数据的线程代码有多条

 * 

 * 当一个线程在执行操作共享数据的多条代码过程中，其他线程参与了云轩。就会导致线程安全问题的产生。

 * 解决思路：

 * 就是将多条操作共享数据的线程代码封装起来，当有线程在执行这些代码的时候，其他线程不可以参与运算的。

 * 必须要当前线程把这些代码都执行完成后，其他线程才可以参与运算。

 * 

 * 在java中，用同步代码块就可以解决这个问题。

同步函数使用的锁是this

 * 同步代码块的格式：

 * synchronized（对象）

 * {

 *  需要被同步的 代码块；

 * }

   同步的好处：解决了线程的安全问题。

 * 同步的弊端：相对降低了效率，因为同步外的线程都会判断同步锁。

同步函数使用的锁是this；

同步函数和同步代码块的区别：

    同步函数的锁是固有的的this。

    同步代码块的锁是任意的对象。

建议使用  同步代码块。

 */

class TicketTest implements Runnable

{

    private int num = 100;

    private Object obj = new Object();

@Override

public void run()

{

// TODO Auto-generated method stub

while(true)

{

synchronized(obj)

{

if(num>0)

{

    System.out.println(Thread.currentThread().getName()+"------------"+num--);

}

else

    break;

}

}

}

}

 public class Ticket

{

public static void main(String[] args)

{

//创建一个线程任务对象

TicketTest t = new TicketTest();

Thread t1 = new Thread(t);

Thread t2 = new Thread(t);

Thread t3 = new Thread(t);

Thread t4 = new Thread(t);

t1.start();

t2.start();

t3.start();

t4.start();

}

}

l 

/*

  * 建立一个线程任务：

  * 目的是  向银行 每次存款 100，  存3次

同步函数使用的锁是this

  */

 class Bkk implements Runnable

 {

     private Bank b = new Bank();

@Override

public void run()

{

// TODO Auto-generated method stub

for(int i=0; i<3; i++)

{

    b.add(100);

}

}

 }

 class Bank

 {

 private int sum;

同步函数使用的锁是this

 public synchronized void add(int num)//同步函数********************

 {

 sum += num;

 System.out.println(sum);

 }

}

================================================================================

死锁问题——

public class LockTest

{

public static void main(String[] args)

{

// TODO Auto-generated method stub

RenWu a = new RenWu(true);

RenWu b = new RenWu(false);

Thread t1 = new Thread(a);

Thread t2 = new Thread(b);

t1.start();

t2.start();

}

}

//任务对象

class RenWu implements Runnable

{

    private Boolean flag;//设定俩中情况

RenWu(Boolean flag)

{

this.flag = flag;

}

@Override

public void run()

{

// TODO Auto-generated method stub

if(flag)//让第一种情况去用第一把锁

{

synchronized (MyLock.Locka)

{

    System.out.println(Thread.currentThread().getName()+".........."+ MyLock.Locka);

synchronized (MyLock.Lockb)//然后想用另外一把锁   这时发现   另外这把锁  有可能就被  另一个任务线程使用着

{

    System.out.println(Thread.currentThread().getName()+".........."+ MyLock.Lockb);

}

}

}

else//让第二种情况去使用  第二把锁   

{

synchronized (MyLock.Lockb)

{

    System.out.println(Thread.currentThread().getName()+".........."+ MyLock.Lockb);

synchronized (MyLock.Locka)//然后想用另外一把锁   这时发现   另外这把锁  有可能就被  另一个任务线程使用着

{

    System.out.println(Thread.currentThread().getName()+".........."+ MyLock.Locka);

}

}

}

}

}

//只有俩把锁    主要有其中一把锁 被锁上了   另外想用这吧锁的  这能等正在用的这把锁被打开后 才能使用

class MyLock

{

final static Object Locka = new Object();

final static Object Lockb = new Object();

}

l