java并发编程线程安全的三种方法

（初学java，纯属个人见解）

package ThreadSynchronization;

public class SyncSomeJava implements Runnable{

	private int ticket=10;//一共有10张票，卖给多个人，公共资源
	
	Object xxx=new Object();
	//创建一个公共对象，作为锁对象给Synchronized去上锁，多个线程都用其他做上锁的依据
	
	@Override
	public void run() {//去执行某项任务，用一个线程模拟一个售票员去售票，只要还有票，就继续，直到卖完为止
		// TODO Auto-generated method stub
		while (true) {//死循环不停的买票
			sell();
			if (ticket<0) {
				break;//但票数小于0，没票了就结束循环
			}
		}
	}
	
	private void sell() {//怎么保证同一时间只能有一个售票员来出票
		// TODO Auto-generated method stub
		//synchronized (xxx) {//同步代码块
			if (ticket>0) {
				//为了保证给多个线程都能有机会买到票，让线程休眠一下
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			//ticket--，卖出一张票，就少一张票
			System.out.println(Thread.currentThread().getName()+"售票："+ticket--);
		}
		
	}

}

package ThreadSynchronization;

public class TestSync {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
        //用三个线程模拟三个售票员
		//公共资源“票”在SyncSomeJava里面
		SyncSomeJava runnable=new SyncSomeJava();
		
		Thread t1=new Thread(runnable,"售票员：张三");
		Thread t2=new Thread(runnable,"售票员：李四");
		Thread t3=new Thread(runnable,"售票员：王五");
		
		t1.start();
		t2.start();
		t3.start();
		//start启动线程后，线程就去抢CPU资源，抢到之后就执行run方法，去做某项任务
	}

}

package ThreadSynchronization;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class TestReentrantLock implements Runnable{
    public int ticket=10;
	
    private final Lock lock = new ReentrantLock();//不能被改，final更专业
    
	@Override
	public void run() {
		// TODO Auto-generated method stub
		while (true) {//死循环不停的卖票
			sell();//调用同步后的方法
			
			if (ticket<0) {
				break;//当票数小于0，没票了就结束循环
			}
		}
	}

	//public synchronized void sell(){//同步方法，保证同一时刻只能有一个线程执行此方法
	private void sell() {
		// TODO Auto-generated method stub
		lock.lock();//线程同步第三种方法：程序员直接使用lock锁对象，更加灵活
		try {
			if (ticket>0) {
				try {
					Thread.sleep(300);
				} catch (InterruptedException e) {
					// TODO: handle exception
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName()+"售票："+ticket--);
			}
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}finally {
			lock.unlock();//卖出一张完成后，要解除锁定，然后所有线程又公平的来抢资源，看谁先抢到，然后锁定
		}
	}
	
	public static void main(String[] args) {
		TestReentrantLock tsm = new TestReentrantLock();
		
		//模拟三个人同时去卖票
		Thread a=new Thread(tsm,"线程a");
		Thread b=new Thread(tsm,"线程b");
		Thread c=new Thread(tsm,"线程c");
		
		a.start();
		b.start();
		c.start();
	}
}

package ThreadSynchronization;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class SyncThrread implements Runnable{
public int ticket=10;
	
    private final Lock lock = new ReentrantLock();//不能被改，final更专业
    
	@Override
	public void run() {
		// TODO Auto-generated method stub
		while (true) {//死循环不停的卖票
			sell();//调用同步后的方法
			
			if (ticket<0) {
				break;//当票数小于0，没票了就结束循环
			}
		}
	}

	//第二种方法：同步方法，简单粗暴方便，把整个需要上锁的方法都锁死，影响比同步代码块要大
	public synchronized void sell(){//怎么保证同一时间只能有一个售票员来出票
	//synchronized (xxx) {//第一种方法：同步代码块，只对部分代码进行上锁，更加精确定位，降低了代码锁定的影响
		// TODO Auto-generated method stub
		lock.lock();//
		try {
			if (ticket>0) {
				//为了保证给多个线程都能有机会买到票，让线程休眠一下
				try {
					Thread.sleep(300);
				} catch (InterruptedException e) {
					// TODO: handle exception
					e.printStackTrace();
				}
				//ticket--，卖出一张票，就少一张票
				System.out.println(Thread.currentThread().getName()+"售票："+ticket--);
			}
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}finally {
			lock.unlock();//卖出一张完成后，要解除锁定，然后所有线程又公平的来抢资源，看谁先抢到，然后锁定
		}
	}
	
	public static void main(String[] args) {
		TestReentrantLock tsm = new TestReentrantLock();
		
		//模拟三个人同时去卖票
		Thread t1=new Thread(tsm,"售票员：张三");
		Thread t2=new Thread(tsm,"售票员：李四");
		Thread t3=new Thread(tsm,"售票员：王五");
		
		t1.start();
		t2.start();
		t3.start();
		
	}
}