java中的线程（二）——线程的同步和synchronized深入理解

class MyThread implements Runnable
{
	int i = 100;
	public void run()
	{
		while(true)
		{
			//Thread.currentThread()获取当前线程的引用
			System.out.println(Thread.currentThread().getName() + i);  
			i--;<span style="white-space:pre">		</span><span style="font-family: Arial, Helvetica, sans-serif;">//当线程t1运行到此处时，线程t2开始运行</span>
			Thread.yield();
			if(i < 0)
			{
		<span style="white-space:pre">	</span>	break;
			}
		}
	}
}

<span style="font-size:18px;">class MyThread implements Runnable
{
	int i = 100;
	public void run()
	{
		while(true)
		{
			synchronized(this)  //代码块，线程同步锁，防止线程共享资源时产生的不协调
			{
				//Thread.currentThread()获取当前线程的引用
				System.out.println(Thread.currentThread().getName() + i);
				i--;
				Thread.yield();
				if(i < 0)
				{
					break;
				}
			}
		}
	}
}</span>

<span style="font-size:18px;">class Test
{
	public static void main(String args [])
	{
		MyThread myThread = new MyThread();
		//生成两个Thread对象，但是这两个Thread对象共用同一个线程体
		Thread t1 = new Thread(myThread);
		Thread t2 = new Thread(myThread);
		//每个线程都有名字，可以通过Thread对象的setName()方法设置线程的名字，也可以通过getName()获取名字
		t1.setName("线程a");
		t2.setName("线程b");

		t1.start();
		t2.start();
	}
}</span>

二、同步代码块和同步方法

同步代码块

1、同步代码块锁住的是对象

2、一个线程获得了一个对象的同步锁，那么这个对象上所有被同步的代码，其他的线程都无法执行

<span style="font-size:18px;">class Service
{
	//1.同步代码块的使用
	public void fun1()
	{
		
		synchronized(this)
		{
			try
			{
				Thread.sleep(3*1000);
			}
			catch (Exception e)
			{
				System.out.println(e);
			}
			System.out.println("fun1");
		}
	}
	public void fun2()
	{
		//1.同步代码块使用，运行其他同步代码块时不能被运行
		synchronized(this)  
		{
			System.out.println("fun2");
		}

		//System.out.println("fun2");可以运行
		
	}
}</span>

<span style="font-size:18px;">class MyThread1 implements Runnable
{
	private Service service;

	public MyThread1(Service service)
	{
		this.service = service;
	}

	public void run()
	{
		service.fun1();
	}
}</span>

<span style="font-size:18px;">class MyThread2 implements Runnable
{
	private Service service;
	public MyThread2(Service service)
	{
		this.service = service;
	}
	public void run()
	{
		service.fun2();
	}
}</span>

<span style="font-size:18px;">class Test
{
	public static void main(String args [])
	{
		Service service = new Service();
		//以下两个对象使用同一个service对象
		Thread t1 = new Thread(new MyThread1(service));
		Thread t2 = new Thread(new MyThread2(service));

		t1.start();
		t2.start();  //该句代码需要等待fun1（）执行完后才能执行
	}
}</span>

同步方法

同步方法锁定的是this

class Service
{
	//2.同步方法  同步方法锁住的是this
	public synchronized void fun1()
	{
		try
		{
			Thread.sleep(10000);
		}
		catch (Exception e)
		{
			System.out.println(e);
		}
		System.out.println("fun1");
	}
	
	//2.同步方法
		public synchronized void fun2() 
		{
			System.out.println("fun2");
		}
}

class MyThread1 implements Runnable
{
	private Service service;

	public MyThread1(Service service)
	{
		this.service = service;
	}

	public void run()
	{
		service.fun1();
	}
}

class MyThread2 implements Runnable
{
	private Service service;
	public MyThread2(Service service)
	{
		this.service = service;
	}
	public void run()
	{
		service.fun2();
	}
}

class Test
{
	public static void main(String args [])
	{
		Service service = new Service();
		Thread t1 = new Thread(new MyThread1(service));
		Thread t2 = new Thread(new MyThread2(service));

		t1.start();
		t2.start();  //该句代码需要等待fun1（）执行完后才能执行
	}
}