一、线程切换

Java中，如果要实现在一个线程间的线程切换，需要在线程中使用Thread.yield()即可让出CPU时间。

二、线程锁（也叫同步锁、互斥锁）

线程锁可以在有效缩小同步范围的同时，尽可能的保证并发效率

2.1 使用synchronized关键字对方法进行加锁

对整个线程处理加锁（严重影响效率，不常用）

2.1.1 语法

public synchronized void test(){
    
}

2.1.2 案例

package com.javase.thread;

import javax.management.RuntimeErrorException;

/**
 * 		这个类主要讲了Sychronized关键字，给方法加了Synchronized关键字以后，线程在调用这个方法时，相当于对这个方法加了锁，
 * 那么其他线程就不能调用这个方法了（处于阻塞状态）
 * 
 * @author gupan
 *
 */
public class ThreadSyncSychronized {
	public static void main(String[] args) {
		final Table2 table = new Table2();
		Thread t1 = new Thread() {
			public void run() {
				while (true) {
					try {
						int bean = table.getBean();
						Thread.yield(); // 线程切换语句，让出CPU时间
						System.out.println(getName() + ","  + table.getBean());
					} catch (RuntimeErrorException e) {
						System.out.println(getName() + ","  + e);
						break;
					}
					
				}
			}
		};
		
		Thread t2 = new Thread() {
			public void run() {
				while (true) {
					try {
						int bean = table.getBean();
						Thread.yield(); // 线程切换语句，让出CPU时间
						System.out.println(getName() + ","  + table.getBean());
					} catch (RuntimeErrorException e) {
						System.out.println(getName() + "," + e);
						break;
					}
				}
			}
		};
		t2.start();
		t1.start();
	}
}

class Table2{
	// 桌子上有20元钱
	private int beans = 20;
	
	public synchronized int getBean() throws RuntimeErrorException{
		if (this.beans == 1) {
			throw new RuntimeErrorException(null, "地主家没有余粮了");
		}
		Thread.yield(); // 线程切换语句，让出CPU时间
		return this.beans--;
	}
}

2.2 使用synchronize关键字对线程方法中的某一部分加锁（同步块的方式）

2.2.1 语法

// 注意这里是this，可以写new Object()，但是这样起不到加锁的效果
// 也就是说，要实现加锁的效果，需要保证是对同一个对象（也就是保证synchronized后面所跟对象是同一个）加锁
synchronized(this){
    ···
    // 加锁语句
}

2.2.2 案例

package com.javase.thread;
/**
 * 这个类主要演示小范围的使用锁。尽可能的提高并发效率
 * 
 * synchronized(this){
 * 		···
 * 		// 加锁语句
 * }
 * 
 * @author Think
 *
 */
public class ThreadSyncLock {
	public static void main(String[] args) {
		final Shop shop = new Shop();
		Thread t1 = new Thread() {
			public void run() {
				shop.buy();
			}
		};
		
		Thread t2 = new Thread() {
			public void run() {
				shop.buy();
			}
		};
		
		t1.start();
		t2.start();
	}
}

class Shop{
	public void buy() {
		Thread t = Thread.currentThread();
		try {
			System.out.println(t.getName() + "正在挑衣服");
			Thread.sleep(1000);
			
			// 需要传入当前方法所属对象，所以这里要传入this
			synchronized (this) {
				System.out.println(t.getName() + "正在试衣服");
				Thread.sleep(1000);
			}
			
			System.out.println(t.getName() + "结账离开");
			Thread.sleep(1000);
		}catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
	}
}

2.3 静态方法加锁

如果对静态方法加了synchronized关键字，由于静态方法只有一份，整个方法一定是加了互斥锁

package com.javase.thread;

import com.javase.string.Object;

/**
 * 静态方法的同步
 * 		当一个静态方法被synchronized修饰以后，那么该方法就是同步方法，由于静态方法从属类，
 * 全局就一份，所以同步的静态方法一定具有同步效果，与对象无关
 * 
 * @author gupan
 *
 */
public class ThreadSyncStatic {	
	public static void main(String[] args) {
		Thread t1 = new Thread() {
			public void run() {
				Foo.dosome();
			}
		};
		Thread t2 = new Thread() {
			public void run() {
				Foo.dosome();
			}
		};
		t1.start();
		t2.start();
	}
}


class Foo{
	public static synchronized void dosome() {
		try {
			Thread t = Thread.currentThread();
			System.out.println(t.getName() + "正在等待运行dosome方法");
			Thread.sleep(1000);
			
			System.out.println(t.getName() + "正在运行dosome方法");
			Thread.sleep(1000);
			
			System.out.println(t.getName() + "执行dosome方法完毕");
		}catch (Exception e) {
			// TODO: handle exception
		}
	}
}

运行结果：

Thread-1正在等待运行dosome方法
Thread-1正在运行dosome方法
Thread-1执行dosome方法完毕
Thread-0正在等待运行dosome方法
Thread-0正在运行dosome方法
Thread-0执行dosome方法完毕

2.3 互斥锁

2.3.1 同步锁和互斥锁

同步锁和互斥锁原理相同，存在的是用法上的小差异。当两个线程调用同一段代码，并且，对于两个线程的同步监视器，看到的代码相同，那就是同步锁；但是，对于几段代码，用一个同步监视器进行访问，几段代码不能同时执行，就是互斥锁

package com.javase.thread;
/**
 * 这段代码主要演示互斥锁的使用
 * 		使用synchronized修饰这段代码之后，只要他们同步监视器对象相同，那么这几段代码见就是互斥关系，多个线程不能同时执行这些代码
 * 
 * @author gupan
 *
 */
public class ThreadSyncMatual {
	/**
	 * 线程t1和t2不能同时调用methodA或methodB方法，实现互斥关系
	 * 
	 * @param args
	 */
	public static void main(String[] args) {
		Boo boo = new Boo();
		Thread t1 = new Thread() {
			public void run() {
				boo.methodA();
			}
		};
		
		Thread t2 = new Thread() {
			public void run() {
				boo.methodB();
			}
		};
		
		t1.start();
		t2.start();
	}
}

class Boo{
	public void methodA(){
		try{
			Thread t = Thread.currentThread();
			System.out.println(t.getName() + "正在执行A方法");
			Thread.sleep(1000);
			System.out.println(t.getName() + "执行A方法完毕");
		}catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
	}
	
	public void methodB(){
		try{
			Thread t = Thread.currentThread();
			System.out.println(t.getName() + "正在执行B方法");
			Thread.sleep(1000);
			System.out.println(t.getName() + "执行B方法完毕");
		}catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
	}
}