java 多线程（4） 线程同步

/* 一，线程安全
 * 1.如本例代码所示
 * {
  * 假如线程demo1在num=1时进入到if(num>0)的判断中然后此时有切换到线程demo2此时线程demo2也是满足条件的，也就是说num
  * 在一定概率下是有可能小于0的
 * }
 * 2，线程安全问题产生的原因
 * (1)多个线程操作共享数据
 * (2).操作共享数据的线程代码有多条
  * 当一个线程在执行共享数据的过程中，其他线程也对共享数据进行了运算就会导致线程安全问题的产生
 * 3.当有两个进程并发修改同一个文件时就有可能造成异常
 * 4.

 class Anquan implements Runnable
	{
		private static int num = 100;
		Object obj=new Object();
		public void run()
		{
			while(true) {
				if(num>0) {//如果当num==1时，从一个此类线程对象切换到另一个此类现线程对象，则就会发生安全问题
				 	System.out.println(Thread.currentThread().getName()+"........."+num--);
				}
		    }
	   }
	}

    public class 线程安全 {	
	public static void main(String []args) {
		Anquan a=new Anquan();
		Thread demo1=new Thread(a);
		Thread demo2=new Thread(a);
		demo1.start();
		demo2.start();
	}
   }

*/

/*二，同步代码块
 * 1.格式:
 * synchronized(obj)
 * {
 *         //同步代码块内容
 * }//obj为同步监视器
 * 2.同步监视器的目的：阻止两个线程对同一个共享资源进行并发访问，通常使用可能被并发访问的共享资源充当同步监视器

 class Anquan implements Runnable
	{
		private static int num = 100;
		Object obj=new Object();
		public void run()
		{
			while(true) {
		    synchronized(obj) {
		   //将此处可能发生线程安全问题的地方设为同步代码块
				if(num>0) {
				 	System.out.println(Thread.currentThread().getName()+"........."+num--);
				}
		    }
			}
		}
	}
    public class 线程安全 {	
	public static void main(String []args) {
		Anquan a=new Anquan();
		Thread demo1=new Thread(a);
		Thread demo2=new Thread(a);
		demo1.start();
		demo2.start();
	}
   }

*/

/*
 * 三，同步方法
 * 1.同步方法就是使用synchronized修饰的某个方法
 * 2.对于synchronized修饰的实例方法而言，无须显示指定同步监视器，同步方法的同步监视器就是this，也就是调用该方法的对象
 * 3.线程安全的类的特征:
 * (1)该类的对象可以被多个线程安全地访问，
 * (2)每个线程调用该对象的任意方法之后都能得到正确的结果
 * (3)每个线程调用该对象的任意方法之后该对象依然保持合理状态    

 class Demo implements Runnable
{

	private static int num=100;
	public synchronized void add() {
		if(num>0)
		{
			System.out.println(Thread.currentThread().getName()+"........."+num--);
		}
	}
	public void run() {
		// TODO Auto-generated method stub
		while(true) {
			add();
		}
	}
    
}
public class 线程同步 
{
	public static void main(String[] args) {
		Demo demo1=new Demo();
		Demo demo2=new Demo();
		Thread demoThread1=new Thread(demo1);
		Thread demoThread2=new Thread(demo2);
		demoThread1.start();
		demoThread2.start();
		System.out.println("aaaaaa");
	}
}

*/

/*四，死锁
 * 1.所有的线程处于阻塞状态，无法继续进行
 * 2.

package 多线程;
class Mylock
{
	public static final Object locka=new Object();
	public static final Object lockb=new Object();
}
class Text implements Runnable
{
	private boolean flag;
	Text(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()+"......if......locka");
					synchronized(Mylock.locka) {
						System.out.println(Thread.currentThread().getName()+"......if......lockb");
						
					}
				}
			}
		}
	}
}
public class 死锁模式 {
	public static void main(String []args) {
		Text demo1=new Text(true);
		Text demo2=new Text(false);
		Thread a=new Thread(demo1);
		Thread b=new Thread(demo2);
		a.start();
		b.start();
	}
}