<b>Java线程:线程的同步-同步块</b>[Java编程]

追其同步的根本的目的,是掌握竞争资源的精确的拜候,因此只要在拜候竞争资源的时刻保证同一时刻只能一个线程拜候便可,因此Java引入了同步代码快的战略,以提高性能.

在上个例子的底子上,对oper办法做了窜改,由同步办法改成同步代码块情势,程序的履行逻辑并没有问题.

/**
*　Java线程:线程的同步-同步代码块
*
*　@author　leizhimin　
*/
public　class　Test　{
　　　　　　　　 public　static　void　main(String[]　args)　{
　　　　　　　　　　　　　　　　 User　u　=　new　User("张三",　100);
　　　　　　　　　　　　　　　　 MyThread　t1　=　new　MyThread("线程A",　u,　20);
　　　　　　　　　　　　　　　　 MyThread　t2　=　new　MyThread("线程B",　u,　-60);
　　　　　　　　　　　　　　　　 MyThread　t3　=　new　MyThread("线程C",　u,　-80);
　　　　　　　　　　　　　　　　 MyThread　t4　=　new　MyThread("线程D",　u,　-30);
　　　　　　　　　　　　　　　　 MyThread　t5　=　new　MyThread("线程E",　u,　32);
　　　　　　　　　　　　　　　　 MyThread　t6　=　new　MyThread("线程F",　u,　21);
　　　　　　　　　　　　　　　　 t1.start();
　　　　　　　　　　　　　　　　 t2.start();
　　　　　　　　　　　　　　　　 t3.start();
　　　　　　　　　　　　　　　　 t4.start();
　　　　　　　　　　　　　　　　 t5.start();
　　　　　　　　　　　　　　　　 t6.start();
　　　　　　　　 }
}
class　MyThread　extends　Thread　{
　　　　　　　　 private　User　u;
　　　　　　　　 private　int　y　=　0;
　　　　　　　　 MyThread(String　name,　User　u,　int　y)　{
　　　　　　　　　　　　　　　　 super(name);
　　　　　　　　　　　　　　　　 this.u　=　u;
　　　　　　　　　　　　　　　　 this.y　=　y;
　　　　　　　　 }
　　　　　　　　 public　void　run()　{
　　　　　　　　　　　　　　　　 u.oper(y);
　　　　　　　　 }
}
class　User　{
　　　　　　　　 private　String　code;
　　　　　　　　 private　int　cash;
　　　　　　　　 User(String　code,　int　cash)　{
　　　　　　　　　　　　　　　　 this.code　=　code;
　　　　　　　　　　　　　　　　 this.cash　=　cash;
　　　　　　　　 }
　　　　　　　　 public　String　getCode()　{
　　　　　　　　　　　　　　　　 return　code;
　　　　　　　　 }
　　　　　　　　 public　void　setCode(String　code)　{
　　　　　　　　　　　　　　　　 this.code　=　code;
　　　　　　　　 }
　　　　　　　　 /**
　　　　　　　　　 *　业务办法　
　　　　　　　　　 *
　　　　　　　　　 *　@param　x　增添x万元
　　　　　　　　　 */
　　　　　　　　 public　void　oper(int　x)　{
　　　　　　　　　　　　　　　　 try　{
　　　　　　　　　　　　　　　　　　　　　　　　 Thread.sleep(10L);
　　　　　　　　　　　　　　　　　　　　　　　　 synchronized　(this)　{
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 this.cash　+=　x;
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 System.out.println(Thread.currentThread().getName()　+　"运行完毕,增添“"　+　x　+　"”,当前用户账户余额为:"　+　cash);
　　　　　　　　　　　　　　　　　　　　　　　　 }
　　　　　　　　　　　　　　　　　　　　　　　　 Thread.sleep(10L);
　　　　　　　　　　　　　　　　 }　catch　(InterruptedException　e)　{
　　　　　　　　　　　　　　　　　　　　　　　　 e.printStackTrace();
　　　　　　　　　　　　　　　　 }
　　　　　　　　 }
　　　　　　　　 @Override　
　　　　　　　　 public　String　toString()　{
　　　　　　　　　　　　　　　　 return　"User{"　+
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 "code='"　+　code　+　'\''　+
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 ",　cash="　+　cash　+
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 '}';
　　　　　　　　 }
}

线程E运行完毕,增添“32”,当前用户账户余额为:132
线程B运行完毕,增添“-60”,当前用户账户余额为:72
线程D运行完毕,增添“-30”,当前用户账户余额为:42
线程F运行完毕,增添“21”,当前用户账户余额为:63
线程C运行完毕,增添“-80”,当前用户账户余额为:-17
线程A运行完毕,增添“20”,当前用户账户余额为:3
Process　finished　with　exit　code　0

注意:

在利用synchronized关键字时刻,应当尽大概避免在synchronized办法或synchronized块中利用sleep大概 yield办法,因为synchronized程序块占据着对象锁,你歇息那么其他的线程只能一边等着你醒来履行完了才能履行.不但严重影响效率,也不合逻辑.

一样,在同步程序块内调用yeild办法让出CPU资源也没有意义,因为你占用着锁,其他互斥线程还是无法拜候同步程序块.当然与同步程序块无关的线程可以得到更多的履行时间.

出处:http://lavasoft.blog.51cto.com/62575/221922