JAVA自学教程之线程的同步问题



JAVA自学教程之线程的同步。

继续以卖票为例

 

一、线程安全问题的解决

同步的第一种表现形式：同步代码块

 

思路：

将多条操作共享数据的线程代码封装起来，当有线程在执行这些代码的时候，其他线程是不允许参与运算的，必须要当期线程把代码执行完毕后，其他线程才可以参与运算

在java中用同步代码块解决这个问题

同步代码块格式：

synchronized（对象）

{

需要被同步的代码部分

}

  1. class Ticket implements Runnable
  2. {
  3.     private int num = 100;
  4.     Object god = new Object();//也可以自定义，建议使用已有的
  5.     public void run()
  6.     {
  7.         while(true)
  8.         {
  9.             synchronized(god) //同步
  10.             {
  11.                 if(num>0)
  12.                 {
  13.                     try
  14.                     {
  15.                         Thread.sleep(10);
  16.                     }
  17.                     catch (InterruptedException e)
  18.                     {
  19.                         // TODO: handle exception
  20.                     }
  22.     System.out.println(Thread.currentThread().getName()+”..sale..”+num–);
  23.             }
  24.             }
  25.         }
  26.     }
  27. }
  28. public class Main
  29. {
  30.     public static void main(String[] args)
  31.     {
  32.         Ticket t = new Ticket();
  33.         Thread j1 = new Thread(t);
  34.         Thread j2 = new Thread(t);
  35.         Thread j3 = new Thread(t);
  36.         Thread j4 = new Thread(t);
  37.         j1.start(); j2.start();
  38.         j3.start(); j4.start();
  39.     }
  40. }
class Ticket implements Runnable
{
	private int num = 100;
	Object god = new Object();//也可以自定义，建议使用已有的
	public void run()
	{
		while(true)
		{
			synchronized(god) //同步
			{
				if(num>0)
				{
					try 
					{
						Thread.sleep(10);
					} 
					catch (InterruptedException e) 
					{
						// TODO: handle exception
					}

	System.out.println(Thread.currentThread().getName()+"..sale.."+num--);	
			}	
			}
		}
	}
}
public class Main 
{
	public static void main(String[] args)
	{
		Ticket t = new Ticket();
		Thread j1 = new Thread(t);
		Thread j2 = new Thread(t);
		Thread j3 = new Thread(t);
		Thread j4 = new Thread(t);
		j1.start(); j2.start(); 
		j3.start(); j4.start();
	}
}

Object的对象就好比一把锁，对同步进行监视操作，当有线程在执行，其他线程不能执行

 

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

同步的弊端：当一个线程sleep时，释放执行权，执行权会给其他线程，然后进行判断同步锁，判断完又进不去，所以相对以前会降低效率，是在可承受的范围内

 

二、同步的前提


如果出现，同步后安全问题还存在，就必须了解同步的前提

前提：同步中必须有多个线程并使用同一个锁（一个线程就没必要同步，多个锁就失去同步的价值）

 

三、同步的第二种表现形式：同步函数

 

  1. /*
  2. * 需求：
  3. * 两个人到银行存钱，每次存10，每个人都是三次
  4. *
  5. * */
  6. class Bank
  7. {
  8.     private int sum;
  9.     private Object obj = new Object();
  10.     //同步代码代码块表现形式
  11.     /*public void add(int num)
  12.     {
  13.         synchronized(obj)
  14.         {
  15.             sum += num;
  16.         try {
  17.             Thread.sleep(10);
  18.         } catch (InterruptedException e) {
  19.             // TODO: handle exception
  20.         }
  21.         System.out.println(“sum = “+sum);
  22.         }
  24.     }*/
  25.     //同步函数表现形式
  26.     public synchronized void add(int num)
  27.     {
  28.         sum += num;
  29.         try {
  30.             Thread.sleep(10);
  31.         } catch (InterruptedException e) {
  32.             // TODO: handle exception
  33.         }
  34.         System.out.println(“sum = “+sum);
  35.     }
  36. }
  37. class Custom implements Runnable
  38. {
  39.     private Bank bank = new Bank();
  40.     public void run()
  41.     {
  42.         for(int i = 0;i<3;i++)
  43.         {
  44.             bank.add(10);
  45.         }
  46.     }
  47. }
  48. class Main
  49. {
  50.     public static void main(String[] args)
  51.     {
  52.         Custom tCustom = new Custom();
  53.         Thread j1 = new Thread(tCustom);
  54.         Thread j2 = new Thread(tCustom);
  55.         j1.start();
  56.         j2.start();
  57.     }
  58. }
/*
 * 需求：
 * 两个人到银行存钱，每次存10，每个人都是三次
 * 
 * */
class Bank
{
	private int sum;
	private Object obj = new Object();
	//同步代码代码块表现形式
	/*public void add(int num)
	{
		synchronized(obj)
		{
			sum += num;
		try {
			Thread.sleep(10);
		} catch (InterruptedException e) {
			// TODO: handle exception
		}
		System.out.println("sum = "+sum);
		}

	}*/
	//同步函数表现形式
	public synchronized void add(int num)
	{
		sum += num;
		try {
			Thread.sleep(10);
		} catch (InterruptedException e) {
			// TODO: handle exception
		}
		System.out.println("sum = "+sum);
	}
}
class Custom implements Runnable
{
	private Bank bank = new Bank();
	public void run() 
	{
		for(int i = 0;i<3;i++)
		{
			bank.add(10);
		}
	}
}
class Main
{
	public static void main(String[] args)
	{
		Custom tCustom = new Custom();
		Thread j1 = new Thread(tCustom);
		Thread j2 = new Thread(tCustom);
		j1.start();
		j2.start();
	}
}

 

验证同步函数的锁是什么？（了解）

  1. class Ticket implements Runnable
  2. {
  3.     private int num = 100;
  4.     Object god = new Object();//也可以自定义，建议使用已有的
  5.     boolean flag = true;
  6.     public void run()
  7.     {
  9.         if(flag==true)
  10.         {
  11.                 while(true)
  12.         {
  13.             synchronized(this) //同步
  14.             {
  15.                 if(num>0)
  16.                 {
  17.                     try
  18.                     {
  19.                         Thread.sleep(10);
  20.                     }
  21.                     catch (InterruptedException e)
  22.                     {
  23.                         // TODO: handle exception
  24.                     }
  26.     System.out.println(Thread.currentThread().getName()+”..obj..”+num–);
  27.             }
  28.             }
  29.         }
  30.         }
  32.         else {
  33.             while(true)
  34.             this.show();
  35.         }
  36.     }
  37.     public synchronized void show()
  38.     {
  39.         if(num>0)
  40.         {
  41.             try
  42.             {
  43.                 Thread.sleep(10);
  44.             }
  45.             catch (InterruptedException e)
  46.             {
  47.                 // TODO: handle exception
  48.             }
  50. System.out.println(Thread.currentThread().getName()+”..fu..”+num–);
  52.     }
  53. }
  54. }
  55. class Main
  56. {
  57.     public static void main(String[] args)
  58.     {
  59.         Ticket t = new Ticket();
  60.         Thread j1 = new Thread(t);
  61.         Thread j2 = new Thread(t);
  63.         j1.start();
  64.         try
  65.         {
  66.             Thread.sleep(10);
  67.         } catch (InterruptedException e)
  68.         {
  69.             // TODO: handle exception
  70.         }
  71.         t.flag = false;
  72.         j2.start();
  73.     }
  74. }
class Ticket implements Runnable
{
	private int num = 100;
	Object god = new Object();//也可以自定义，建议使用已有的
	boolean flag = true;
	public void run()
	{

		if(flag==true)
		{
				while(true)
		{
			synchronized(this) //同步
			{
				if(num>0)
				{
					try 
					{
						Thread.sleep(10);
					} 
					catch (InterruptedException e) 
					{
						// TODO: handle exception
					}

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

		else {
			while(true)
			this.show();
		}
	}
	public synchronized void show()
	{
		if(num>0)
		{
			try 
			{
				Thread.sleep(10);
			} 
			catch (InterruptedException e) 
			{
				// TODO: handle exception
			}

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

	}
}
}
class Main 
{
	public static void main(String[] args)
	{
		Ticket t = new Ticket();
		Thread j1 = new Thread(t);
		Thread j2 = new Thread(t);

		j1.start(); 
		try 
		{
			Thread.sleep(10);
		} catch (InterruptedException e) 
		{
			// TODO: handle exception
		}
		t.flag = false;
		j2.start(); 
	}
}

 

同步函数的使用的锁是this

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

同步函数的锁是固定的this，同步代码块的锁是任意的

所以同步时，建议使用同步代码块

 

验证静态同步函数的锁是什么？（了解）

静态同步函数的锁不是this，因为根本没有this

  1. class Ticket implements Runnable
  2. {
  3.     private static int num = 100;
  4.     Object god = new Object();//也可以自定义，建议使用已有的
  5.     boolean flag = true;
  6.     public void run()
  7.     {
  9.         if(flag==true)
  10.         {
  11.                 while(true)
  12.         {
  13.             synchronized(this.getClass())
  14.             //synchronized(Ticket.class)
  15.             {
  16.                 if(num>0)
  17.                 {
  18.                     try
  19.                     {
  20.                         Thread.sleep(10);
  21.                     }
  22.                     catch (InterruptedException e)
  23.                     {
  24.                         // TODO: handle exception
  25.                     }
  27.     System.out.println(Thread.currentThread().getName()+”..obj..”+num–);
  28.             }
  29.             }
  30.         }
  31.         }
  33.         else {
  34.             while(true)
  35.             this.show();
  36.         }
  37.     }
  38.     public static synchronized void show()
  39.     {
  40.         if(num>0)
  41.         {
  42.             try
  43.             {
  44.                 Thread.sleep(10);
  45.             }
  46.             catch (InterruptedException e)
  47.             {
  48.                 // TODO: handle exception
  49.             }
  51. System.out.println(Thread.currentThread().getName()+”..fu..”+num–);
  53.     }
  54. }
  55. }
  56. class Main
  57. {
  58.     public static void main(String[] args)
  59.     {
  60.         Ticket t = new Ticket();
  61.         Thread j1 = new Thread(t);
  62.         Thread j2 = new Thread(t);
  64.         j1.start();
  65.         try
  66.         {
  67.             Thread.sleep(10);
  68.         } catch (InterruptedException e)
  69.         {
  70.             // TODO: handle exception
  71.         }
  72.         t.flag = false;
  73.         j2.start();
  74.     }
  75. }
class Ticket implements Runnable
{
	private static int num = 100;
	Object god = new Object();//也可以自定义，建议使用已有的
	boolean flag = true;
	public void run()
	{

		if(flag==true)
		{
				while(true)
		{
			synchronized(this.getClass()) 
			//synchronized(Ticket.class)
			{
				if(num>0)
				{
					try 
					{
						Thread.sleep(10);
					} 
					catch (InterruptedException e) 
					{
						// TODO: handle exception
					}

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

		else {
			while(true)
			this.show();
		}
	}
	public static synchronized void show()
	{
		if(num>0)
		{
			try 
			{
				Thread.sleep(10);
			} 
			catch (InterruptedException e) 
			{
				// TODO: handle exception
			}

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

	}
}
}
class Main 
{
	public static void main(String[] args)
	{
		Ticket t = new Ticket();
		Thread j1 = new Thread(t);
		Thread j2 = new Thread(t);

		j1.start(); 
		try 
		{
			Thread.sleep(10);
		} catch (InterruptedException e) 
		{
			// TODO: handle exception
		}
		t.flag = false;
		j2.start(); 
	}
}

静态同步函数的锁 该函数所属字节码文件对象

 

可以使用getClass方法获取，也可以使用 当前 类名.class获取