详述线程间数据共享

线程中并发指一个时间段中多个线程都处于已启动但没有运行结束的状态。
多个线程之间默认并发运行，这种运行方式往往会出现交叉的情况。

package venus;

public class Test {
    public static void main(String[] args) {
        new CounterThread("~~~~~~~~~~~~~~~").start();
        new CounterThread("@@@@@@@@@@@@@@@").start();
    }
}

class CounterThread extends Thread {

    CounterThread(String name){
        super(name);
    }

    @Override
    public void run() {
            for (int i = 0; i < 5; i++) {
                System.out.println(getName() + i);
            }
    }
}

 出现交叉的情况：

想要使得原本并发运行的线程实现串行运行，需要通过对象锁机制来实现，synchronized就是一个利用锁实现线程同步的关键字。

例：

package venus;

import java.util.Date;

public class Test {
    public static void main(String[] args) {
        Object object = new Object();
        new CounterThread("~~~~~~~~~~~~~~~",object).start();
        new CounterThread("@@@@@@@@@@@@@@@",object).start();
    }
}

class CounterThread extends Thread {
    Object object;

    CounterThread(String name,Object object){
        super(name);
        this.object = object;
    }

    @Override
    public void run() {
        synchronized (object) {//synchronized对象锁：该对象锁是Java中创建的一个对象，该对象可由任意类创建，只要求所创建的对象在多个线程之间共享即可。如果对象锁为全局成员，为了保证该对象在多个线程间共享，该成员往往被private static final修饰。

            for (int i = 0; i < 5; i++) {
                System.out.println(getName() + i);
            }
        }
    }
}

通过synchronized关键字实现了线程串行运行：一个线程执行完synchronized 代码块后另一个线程才执行，但是哪个线程先执行synchronized 代码块中的代码无法确定。

为什么通过synchronized就能实现多线程间串行运行呢？

被synchronized括着的部分就是线程执行临界区，每次仅能有一个线程执行该临界区中的代码：当多个线程中的某个线程先拿到对象锁， 则该线程执行临界区内的代码，其他线程只能在临界区外部等待，当此线程执行完临界区中的代码后，在临界区外部等待的其他线程开始再次竞争以获取对象锁，进而执行临界区中的代码，但只能有一条线程“胜利”。

临界区中的代码具有互斥性、唯一性和排它性：一个线程只有执行完临界区中的代码另一个线程才能执行。

☆例子：

import java.text.*;
import java.util.Date;

public class Test {

	public static void main(String[] args) {
		Object lockObj = new Object();
		new DisplayThread(lockObj).start();
	}
}

class DisplayThread extends Thread {

	Object lockObj;

	public DisplayThread(Object lockObj) {
		this.lockObj = lockObj;
	}

	@Override
	public void run() {
		synchronized (lockObj) {
			new TimeThread(lockObj).start();
			try {
				sleep(60000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

class TimeThread extends Thread {

	Object lockObj;

	public TimeThread(Object lockObj) {
		this.lockObj = lockObj;
	}

	@Override
	public void run() {
		System.out.println("时间线程开始执行......");
		synchronized (lockObj) {
			DateFormat dateFormat = new SimpleDateFormat("HH:mm:ss");
			String time = dateFormat.format(new Date());
			System.out.println(time);//为什么这行代码60秒左右才会执行？
			//显示器线程和时间线程共享lockObj对象，显示器线程优先进入启动状态，随后执行相应的run方法，当执行同步代码块时lockObj变量所代表的对象锁归显示器线程所有，
			//进而创建时间线程并使之处于启动状态，此时有一下两种状态：
			//1、时间线程马上进入执行状态，
			//马上执行该时间线程run方法,可是由于此时lockObj变量所代表的对象锁被显示器线程持有，
			//这时时间线程进入阻塞状态，显示器线程再次执行，然后执行sleep方法，显示器线程在继续持有对象锁的前提下
			//也进入阻塞状态，60秒后显示器线程进入执行状态，随后显示器线程结束，对象锁被释放，进而时间线程开始执行，进而这行代码运行；
			//2、时间线程并没有马上进入执行状态，显示器线程执行sleep方法，显示器线程在继续持有对象锁的前提下
			//也进入阻塞状态，此时时间线程进入执行状态，执行该时间线程run方法,执行该方法中第一行输出代码，
			//可是由于此时lockObj变量所代表的对象锁被显示器线程持有，
			//所以时间线程并没有执行时间线程run方法内临界区中的代码,这时时间线程也进入阻塞状态，此时显示器和时间两条线程均进去阻塞状态，
			//等待少于60秒的时间后，显示器线程进入运行状态，随后显示器线程结束，对象锁被释放，进而时间线程开始执行，进而这行代码运行；
		}
	}
}

synchronized同步关键字有两种使用方式：

public synchronized void methodName( ){
	//同步操作方法体
}

synchronized (需要同步操作的对象) {
	      //同步对象操作的语句
}