JAVA多线程

最新推荐文章于 2022-05-13 10:01:03 发布

免费的人

最新推荐文章于 2022-05-13 10:01:03 发布

阅读量225

点赞数

CC 4.0 BY-SA版权

分类专栏： JAVA基础文章标签： java 多线程

本文链接：https://blog.youkuaiyun.com/weixin_43460927/article/details/107843412

JAVA基础专栏收录该内容

5 篇文章

订阅专栏

本文详细介绍了JAVA多线程的创建方式，包括继承Thread类和实现Runnable接口，并讲解了线程的生命周期、线程控制（如join、sleep、yield）、线程安全（同步代码块、同步方法）以及生产者消费者模式。此外，还讨论了JMM（Java内存存储模型）和volatile关键字的作用，最后提到了公平锁与非公平锁的概念及其应用场景。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

JAVA多线程

一、线程创建

在java中，线程用Thread类表示，所有的线程对象都是Thread类或子类的对象。
要想开发一个线程类，有两种方式：
1、继承Thread类，重写run方法。
首先开发我们的线程类，我们暂且称为这个类为A，类要继承Thread类。
重写Thread类的run方法。run方法就是你的线程要完成的功能。
创建A的实例，调用start方法启动这个线程。
注意这里不要调用run方法，如果调用run方法，就相当于run是一个普通方法，而不是线程了。一定通过Thread类的start方法来启动线程。

实例代码：
public class MyFirstThread extends Thread {
	public int i;
	@Override
	public void run() {
		while (i++ < 100) {
			System.out.println(this.getName() + ":i=" + i);
		}
	}

	public static void main(String[] args) {
		MyFirstThread thread1 = new MyFirstThread();
		MyFirstThread thread2 = new MyFirstThread();
		thread1.start();
		thread2.start();
	}
}

在这个代码中，我们开发了一个类MyFirstThread，并继承了Thread类，重写了run方法。
在run方法中，我们循环100次打印int类型的i。这里的this.getName是得到当前线程的名字。在main方法中，我们创建了线程对象的两个实例thread1和thread2，并分别调用它们的start方法启动这两个线程。
部分运行结果如下：

Thread-0:i=23
Thread-1:i=2
Thread-0:i=24
Thread-1:i=3
Thread-0:i=25
Thread-1:i=4
Thread-0:i=26
Thread-1:i=5

2、实现Runnable接口，实现run方法。
这里和前面的用法一样。实现Runnable接口，实现run方法。只是在调用的时候，需要将实现Runnable接口的类对象置入Thread类中，作为Thread的target来启动。

这里需要注意，Runnable对象是Thread对象的target，Runnable中的run方法是作为线程的执行体。最重仍然使用Thread类负责执行target的run方法。

查看Thread类的源代码：

public
class Thread implements Runnable {
/* What will be run. */
    private Runnable target;
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
}

可以看到Thread类和Runnable接口之间的关系。

示例代码：
public class MySecondThread implements Runnable{

	public int i;
	@Override
	public void run() {
		// TODO Auto-generated method stub
		while (i++ < 100) {
			//下面的代码编译失败，Runnable没有getName方法
		//	System.out.println(this.getName() + ":i=" + i);
			System.out.println(Thread.currentThread().getName() + ":i=" + i);
		}
	}
	public static void main(String[] args) {
		MySecondThread thread1 = new MySecondThread();
		MySecondThread thread2 = new MySecondThread();
		//下面两行代码编译失败，Runnable没有start方法
//		thread1.start();
//		thread2.start();
		Thread t1 = new Thread(thread1);
		Thread t2 = new Thread(thread2);
		t1.start();
		t2.start();
	}
}

3 线程的生命周期
当线程被创建并且启动后，它经历了5种状态：新建、就绪、运行、阻塞和死亡状态。当线程在运行的时候，不能一直占有CPU时间片，CPU会在多个线程之间进行调度，线程的状态也会多次切换于阻塞和运行状态。
当线程对象被创建出来是进入了新建状态，当调用了start方法后，线程进入就绪状态。这里可能读者的理解是线程start后进入运行状态，其实线程内部还是依赖JVM的调度，当调用了start方法后，JVM会认为这个线程可以执行，至于什么时候执行取决于JVM的内部调度。
如果就绪状态的线程获取了CPU，那么这个线程处于运行状态，当这个线程运行时，不会一直霸占CPU，线程在执行的过程中会被在CPU上调度下来，以便其他线程能够获取执行机会。
线程进入阻塞状态的情况：
线程调用一个阻塞方法，方法返回前该线程一直阻塞。
线程调用sleep方法进入阻塞。
线程尝试获取同步监视器，但该同步监视器被其他线程持有。
线程调用了suspend方法挂起。
线程解除阻塞，重新进入就绪状态的情况：
调用的阻塞方法返回。
调用的sleep到期。
线程成功获取同步监视器。
被suspend的方法挂起的线程被调用了resume方法恢复。
线程的死亡状态就是线程的结束，线程结束的情况有如下几种：
run方法执行完成
线程抛出异常
直接调用线程的stop方法结束线程
判断线程是否死亡可以使用isAlive方法，当线程处于就绪、运行和阻塞三种状态的时候返回true，否则返回false。另外，不能对已经死亡的线程重新调用start方法重新启动。
另外，线程的suspend方法和stop方法非常容易导致死锁，一般不推荐使用。
本小节中提到的一些名词，如同步监视器，在后面章节会有详细讲解。

二、线程控制

1、 join线程
当一个线程需要等待另一个线程完毕再执行的话，可以使用Thread的join方法。
假设线程A和线程B，在A执行时调用了B的join方法，A将被阻塞，一直等到B线程执行完毕后，A线程继续执行，就好像排队加塞。

示例代码：
public class TestJoinThread {
	public static void main(String[] args) {
		MainThread mt = new MainThread();
		mt.start();
	}
}

class MainThread extends Thread {
	public void run() {
		// TODO Auto-generated method stub
		for (int i = 0; i < 50; i++) {
			if (i == 30) {
				JoinThread jt = new JoinThread();
				jt.setName("join线程");
				jt.start();
				try {
					jt.join();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			System.out.println(this.getName() + " " + i);
		}
	}
}

class JoinThread extends Thread {
	@Override
	public void run() {
		// TODO Auto-generated method stub
		for (int i = 0; i < 50; i++) {
			System.out.println(this.getName() + " " + i);
		}
	}
}

运行结果：

Thread-0 27
Thread-0 28
Thread-0 29
join线程 0
join线程 1
join线程 2
…
join线程 46
join线程 47
join线程 48
join线程 49
Thread-0 30
Thread-0 31
Thread-0 32
Thread-0 33
…
Thread-0 48
Thread-0 49

可以看到Main线程正常运行，调用了另外一个线程JoinThread的join方法，那么Main线程等待JoinThread执行完毕后再执行。

2、线程睡眠
如果让线程休息一会，我们可以使用Thread的静态方法sleep(long millis)。这个方法的意思是：在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。
sleep方法会让线程休息指定的毫秒数，在sleep的时候，不会放弃执行权力，等待休息时间到了，马上获取执行机会。也就是说，在这个线程sleep的时候，其他线程不会获得CPU的执行权力。

示例代码：
public class TestThreadSleep {
	public static void main(String[] args) {
		for (int i = 0; i < 50; i++) {
			System.out.println(i);
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

程序将每隔一秒打印一下变量i的值。

3、线程让步
线程让步和线程睡眠差不多，但是有一个重要的区别。是让当前线程暂停执行，会放弃cpu的执行权力。也就是说，会让操作系统的线程调度器重新调度一下，其他的线程都有可能获取到执行的权力。
我们知道，每一个时间点只有一个线程可以执行，而其他的线程都是竞争cpu的执行权力，然而调用正在执行线程的让步方法后，所有的线程就会一拥而上，一起竞争cpu的执行权力。

线程让步的方法是Thread的yield静态方法。

3.1 线程优先级
每个线程执行时都具备一个优先级，优先级越高越容易获得执行机会，优先级越低获得的执行机会越少。默认情况下，如果不设置，线程都具备普通优先级。
另外，并不一定是拥有优先级高的线程和有用优先级低的线程在竞争时，优先级高的就一定能获取执行机会。
Thread类的setPriority(int newPriority)和getPriority()方法能够设置和查看线程的优先级。
其中，setPriority方法的参数是一个int整数，范围是1-10，更经常的，我们使用Thread类的三个静态变量来设置：
static int MAX_PRIORITY
线程可以具有的最高优先级。值是10
static int MIN_PRIORITY
线程可以具有的最低优先级。值是1
static int NORM_PRIORITY
分配给线程的默认优先级。值是5

示例代码：
public class Test {
	public static void main(String[] args) {
		Thread t1 = new MyThread1();
		Thread t2 = new Thread(new MyRunnable());
		t1.setPriority(Thread.MAX_PRIORITY);
		t2.setPriority(Thread.MIN_PRIORITY);
		t2.start();
		t1.start();
	}
}

class MyThread1 extends Thread {
	public void run() {
		for (int i = 0; i < 1000; i++) {
			System.out.println("线程1第" + i + "次执行！");
			try {
				Thread.yield();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}
}

class MyRunnable implements Runnable {
	public void run() {
		for (int i = 0; i < 1000; i++) {
			System.out.println("线程2第" + i + "次执行！");
			try {
				Thread.yield();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}
}

三、线程安全

1 、同步代码块
同步代码块，就是定义了一组原子性代码。所谓原子性代码，就是说在这一组代码块中，只允许一个线程进入。直到这个线程运行完毕，下一个线程才可以进入。同步代码块的格式如下：

synchronized (obj) {
			
		}

这里的obj，我们可以理解为一把锁，叫做同步监视器。
我们考虑代码1，打印字符串的这一块代码，如果我们要将其保护起来，只允许同一时间点只有一个线程调用，那么可以使用同步代码块。
示例代码：
package com.langsin.threadTest;

/**
 * 测试多线程情况下使用同步代码块
 */
public class SafeThreadTest {

	V v = new V();
	public static void main(String[] args) {
		SafeThreadTest test = new SafeThreadTest();
		test.test();
	}
	/**
	 * 开两个线程，分别调用V对象的打印字符串的方法
	 */
	public void test(){
		new Thread(new Runnable() {
			@Override
			public void run() {
				while(true){
					v.printString("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA");
				}
			}
		}).start();
		new Thread(new Runnable() {
			@Override
			public void run() {
				while(true){
					v.printString("BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB");
				}
			}
		}).start();
	}
	/**
	 * 这个类负责打印字符串
	 * @author Administrator
	 */
	class V {
		/**
		 * 为了能使方法运行速度减慢，我们一个字符一个字符的打印
		 * @param s
		 */
		Object lock = new Object();
		public void printString(String s){
			synchronized (lock) {
				for(int i = 0;i<s.length();i++){
					System.out.print(s.charAt(i));
				}
				System.out.println();
			}
		}
	}
}

执行结果：
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

我们看到代码执行正确。
在这里，**Object lock = new Object();**这段代码其实没有什么具体意义。只是生成一个对象，在同步代码块中就用这个对象充当锁。
这里一定要注意一个问题，这一把锁到底是否可以用。
在这里，是否可以用this？是否可以用printString方法的形式参数s？

我们来分析一下。在SafeThreadTest类中，我们一开始就创建了V这个类的对象。V v = new V(); 然后在test方法中生成两个Thread对象，都用这一个V对象去打印字符串。因此，在类V中Object lock = new Object();这段代码的lock对象，只生成过一次。也就是说两个Thread对象使用的v对象是一个对象！所以可以在同步代码块中使用lock，同样也可以使用this。
但是，如果使用printString的形式参数s作为同步监视对象：

synchronized (s) {
			
		}

这样是不行的。因为在两个线程中，调用了v对象的printString方法。然而两个线程调用这个方法的时候传入的字符串s 不是同一个对象。也就是说”AAAAAAAAAAAAA”!=”BBBBBBBBB”,所以两个线程拿到的锁都不是一个锁，根本起不到线程互斥的作用。所以用s是不行的。

如果，同步代码块置于静态方法中，那么锁对象就不能是用this了，而应该是使用类的字节码。读者可以考虑下为什么。
示例代码：

import java.io.ObjectInputStream.GetField;

/**
 * 测试多线程情况下使用同步代码块
 */
public class SafeThreadTest2 {

	public static void main(String[] args) {
		SafeThreadTest2 test = new SafeThreadTest2();
		test.test();
	}
	/**
	 * 开两个线程，分别调用V对象的打印字符串的方法
	 */
	public void test(){
		new Thread(new Runnable() {
			@Override
			public void run() {
				while(true){
					V.printString("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA");
				}
			}
		}).start();
		new Thread(new Runnable() {
			@Override
			public void run() {
				while(true){
					V.printString("BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB");
				}
			}
		}).start();
	}
	/**
	 * 这个类负责打印字符串
	 * @author Administrator
	 */
	static class V {
		/**
		 * 为了能使方法运行速度减慢，我们一个字符一个字符的打印
		 * @param s
		 */
		public static void printString(String s){
			synchronized (V.class) {
				for(int i = 0;i<s.length();i++){
					System.out.print(s.charAt(i));
				}
				System.out.println();
			}
		}
	}
}

2、同步方法
synchronized关键字也可以放到方法上，这样整个方法就是同步的。同步监视器就是类对象本身this。
只需要将前面的代码换成如下即可：

public synchronized void printString(String s){
				for(int i = 0;i<s.length();i++){
					System.out.print(s.charAt(i));
				}
				System.out.println();
			}
		}

注意：synchronized关键字可以修饰方法、代码块，但是不能修饰构造方法和属性。

线程要进入同步代码块或同步方法中，必须先获得同步监视器的锁定。也就是说必须先拿到锁，然后进入方法。那么什么时候释放锁呢？
1.方法执行结束
2.在方法中遇到Exception，导致异常
3.程序中遇到了退出程序的代码，比如return
4.程序执行了同步监视器对象的wait()方法

四、生产者消费者

当线程A运行过程中遇到不满足的条件需要等待，等待另外的线程B去更改系统状态。当B更改系统状态后，唤醒等待线程A。等待线程A查看是否满足条件，如果满足则继续执行，不满足则继续等待。
举个例子。在ATM中，有两个线程。一个用来存款，一个用来提款。当提款的线程提款时，发现余额不足，那么它等待有线程过来存款。一旦有线程存款，那么马上唤醒这个提款的线程。提款的线程继续查看是否余额大于提款额度，如果大于，则提款，否则继续等待。
这个功能的实现可以借助于Object类的wait notify和notifyAll方法，注意，这三个方法不是Thread类的方法，而是Object类方法。
另外，要使用这些方法，必须获得同步监视器对象。

我们先来看一个简单的示例，两个线程A和B，线程A先执行，然后线程B再执行。两个线程交替执行。
示例代码：

/**
 * 运行两个线程，然后这两个线程交替执行，A先执行，执行完毕,B执行 wait notify notifyAll 都是Object的方法
 * wait方法只能在 获取同步监视锁的方法中或代码块中才能调用 同步监视锁既是 synchronized
 */
public class Testwait {
	public static void main(String[] args) {
		final LoopTest lt = new LoopTest();
		new Thread(new Runnable() {
			@Override
			public void run() {
				// TODO Auto-generated method stub
				while (true)
					lt.f1();
			}
		}, "线程A").start();
		new Thread(new Runnable() {
			@Override
			public void run() {
				// TODO Auto-generated method stub
				while (true)
					lt.f2();
			}
		}, "线程B").start();
	}
}
class LoopTest {
	boolean flag = false;
	public synchronized void f1() {
		while (flag) {
			try {
				wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		} 
			System.out.println(Thread.currentThread().getName());
			flag = true;
			notifyAll();
	}

	public synchronized void f2() {
		while (!flag) {
			try {
				wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		} 
			System.out.println(Thread.currentThread().getName());
			flag = false;
			notifyAll();
	}

}

执行结果：

线程A
线程B
线程A
线程B
线程A
线程B

在这段代码中，我们开启了两个线程，线程中的run方法调用了LoopTest类对象的f1方法。在f1方法中，首先必须获得同步监视器对象，也就是必须有synchronized才可以使用wait和notifyAll。第一个线程进入f1方法，发现flag为false，没有进入if代码块，将flag设置为true(这时候另外一个线程可能已经进入f1方法，发现flag为false，于是进入wait状态)，同时唤醒正在wait状态的所有线程(这里使用的notifyAll)。这时候，进入wait状态的线程会被唤醒，继续检查是否满足条件，如果满足条件则运行，否则继续等待。

1、生产者消费者问题
很多情况下，我们需要这样的模型。大家可以想象一下吃自助餐。在自助餐的公共区域有很多食物，我们(消费者)可以去挑选食物。然而，这时候食物被我们选没了，于是大家伙都等待。在等待什么呢？等待厨师做出新的一批食物放置上来，我们就可以继续选择我们喜爱的食物。
同样，如果反过来理解的话也可以。我们可以制造一些请求，这些请求放到一个队列中。队列的另一端会处理请求。如果队列中有请求，那么处理请求，没有的话等待请求的到来。我们在队列中放入请求的时候，如果队列满了，我们就等待处理请求处理完一个请求，于是我们可以放入新的请求。
我们用代码来模拟第二种情况：
Request：请求对象
RequestContainer：存放请求的容器(重要)
ProcessRequestThread: 处理请求的线程
MakeRequestThread：制造请求的线程

示例代码 Request

/**
 * 请求对象
 */
public class Request {

	private String id;
	private String name;
	
	public Request(String id, String name) {
		this.id = id;
		this.name = name;
	}

	public void doSth(){
		System.out.println("id:"+id+" name:"+name+" 被处理");
	}

	@Override
	public String toString() {
		return "Request [id=" + id + ", name=" + name + "]";
	}
	
}

示例代码 RequestContainer
package com.langsin.threadTest.produceConsumer;

import java.util.LinkedList;

/**
 * 存放请求的容器
 *
 */
public class RequestContainer {

	private final LinkedList<Request> buffer;
	private int MAX; 				//容器允许的最大值
	
	public RequestContainer(
			int MAX) {
		this.buffer = new LinkedList<Request>();
		this.MAX = MAX;
	}

	public int size(){
		return buffer.size();
	}
	public synchronized void put(Request request) throws InterruptedException{
		
		while(buffer.size() >= MAX){
			wait();
		}
		System.out.println(Thread.currentThread().getName()+"放入请求"+request);
		buffer.add(request);
		notifyAll();
	}
	
	public synchronized Request get() throws InterruptedException{
		while(buffer.size() <= 0){
			wait();
		}
		Request r = buffer.removeFirst();
		notifyAll();
		return r;
	}
	
}
示例代码 MakeRequestThread
import java.util.UUID;
/**
 * 制造请求的线程
 */
public class MakeRequestThread extends Thread{
	private final RequestContainer container;
	
	public MakeRequestThread(RequestContainer container, String name) {
		super(name);
		this.container = container;
	}

	@Override
	public void run() {
		while(true){
			try {
				Thread.sleep((long) (Math.random()*1000));
				Request request = new Request(UUID.randomUUID().toString(), getName());
				container.put(request);
			} catch (InterruptedException e) {
			}
		}
	}
}

示例代码 ProcessRequestThread
package com.langsin.threadTest.produceConsumer;

/**
 * 处理请求的线程
 */
public class ProcessRequestThread extends Thread {
	private final RequestContainer container;

	public ProcessRequestThread(RequestContainer container, String name) {
		super(name);
		this.container = container;
	}

	@Override
	public void run() {
		while (true) {
			try {
				Thread.sleep((long) (Math.random()*1000));
				Request request = container.get();
				request.doSth();
				System.out.println("当前容器："+container.size());
			} catch (InterruptedException e) {
			}
		}
	}
}

示例代码 Go
package com.langsin.threadTest.produceConsumer;

/**
 * 运行代码 
 */
public class Go {

	public static void main(String[] args) {
		RequestContainer container = new RequestContainer(1);
		
		new MakeRequestThread(container, "生产者1").start();
		new MakeRequestThread(container, "生产者2").start();
		new MakeRequestThread(container, "生产者3").start();
		
		new ProcessRequestThread(container, "消费者1").start();
	}
}

执行结果：

生产者3放入请求Request [id=7b727192-1b8e-4903-bbed-a33fca8f7f96, name=生产者3]
id:7b727192-1b8e-4903-bbed-a33fca8f7f96 name:生产者3 被处理
生产者1放入请求Request [id=ec86e050-d6bc-4037-bfec-b089d36cc7c7, name=生产者1]
当前容器：0
id:ec86e050-d6bc-4037-bfec-b089d36cc7c7 name:生产者1 被处理
生产者1放入请求Request [id=3d04a636-3fb6-4307-b229-fdbe3ee9116d, name=生产者1]
当前容器：0
id:3d04a636-3fb6-4307-b229-fdbe3ee9116d name:生产者1 被处理
生产者1放入请求Request [id=d36a99e2-f188-4f14-8252-cc03c5e2aca7, name=生产者1]
当前容器：0
id:d36a99e2-f188-4f14-8252-cc03c5e2aca7 name:生产者1 被处理
生产者2放入请求Request [id=01bde50f-50c9-4c93-9464-824f01329c9b, name=生产者2]
当前容器：0
id:01bde50f-50c9-4c93-9464-824f01329c9b name:生产者2 被处理
生产者3放入请求Request [id=7b4f4a83-d2d6-42d2-9942-6b4862d39132, name=生产者3]
当前容器：0
id:7b4f4a83-d2d6-42d2-9942-6b4862d39132 name:生产者3 被处理
生产者3放入请求Request [id=715c7414-8b2e-4550-a3c6-2dd916e13448, name=生产者3]
当前容器：0
id:715c7414-8b2e-4550-a3c6-2dd916e13448 name:生产者3 被处理
生产者3放入请求Request [id=6c159dac-e418-4009-8c46-6a11c8a6a380, name=生产者3]
当前容器：0
id:6c159dac-e418-4009-8c46-6a11c8a6a380 name:生产者3 被处理
生产者3放入请求Request [id=beb39eca-4571-4367-8cf3-ade9ef929e61, name=生产者3]
当前容器：0

2、 Future 提前完成任务
假设有两个方法A和B。A调用B。如果B方法执行起来比较长，那么就会导致A方法的阻塞等待，直到B方法完毕后，A方法才能被返回。类似于购买物品，先生成订单，然后等产品真正到位，我们在拿订单换取产品。
Future的目标就是在B方法没有实际完成的情况下，提前返回，然后自己在慢慢做。

五、JMM – java内存存储模型

1、 JAVA内存存储模型
首先我们分析一下硬件设备中并发的问题。我们知道，计算机的存储速度和CPU运算的速度是不匹配的，也就是说CPU的运算速度大大快于计算机存储速度。为了解决这种阻抗不匹配，计算机必须引入一种机制来解决这样的问题。计算机引入高速缓存区来作为内存与CPU之间的桥梁，首先，将需要运算的数据放置到高速缓存中，加快运算速度，运算结束后，将缓存中的数据同步到内存中取，因此CPU不需要等待内存读写。
这样的模型结构带来的直接问题就是高速缓存数据一致性的问题。在多核CPU中，每个处理器都有自己的高速缓存区，这些高速缓存同时共享计算机的主内存区域，如果多个CPU同时对主内存区域进行写回操作，这时候就会出现问题。为了解决数据不一致性，各个CPU都需要遵守协议，进行IO的时候遵守协议。类似的协议有MSI、MOSI等。
另外的，为了能使CPU内部运算能够充分发挥，CPU会对输入的代码进行乱序执行优化策略：CPU计算后，将乱序执行的结果进行重组，保证和不乱序的执行结果是一致的。

JAVA内存模型和硬件内存模型基本类似，称作Java Memory Model  JMM.以此来屏蔽硬件和操作系统对内存访问的差异性。

2、主存与工作内存
java内存模型的主要目标是定义程序中各个变量的访问规则，也就是在jvm中将变量存储到内存和从内存中取出变量这样的底层细节。
此处的变量与java编程所说的变量略有区别，主要是不包括局部变量和方法参数。因为这两个是线程私有的，不会被共享，自然就不存在竞争。
jmm规定了所有的变量都存储在主存中。每条线程还有自己的工作内存，线程的工作内存中保存了被线程使用到的变量和主存副本拷贝，线程对变量的所有操作都必须在工作内存中进行，而不能直接读写主存中的变量。不同线程之间也无法直接方位对方工作内存中的变量，线程变量值的传递需要通过主内存来完成。

2.1、内存交互
主存和工作内存之间的交互协议
JAVA内存存储模型是通过动作(actions)的形式描述。这些动作也就是变量如何在主内存进入到工作内存、工作内存中的数据如何进入主内存。具体包括了：
lock unlock read load use assign store write。

lock 作用于主存变量，把一个变量标识成为线程独占状态
unlock 作用于主存变量，把一个锁定的变量释放出来，释放后的变量才能被其他线程锁定。
read 作用于主内存变量，把一个变量的值从主内存传输到线程的工作内存。
load 作用于工作内存变量，把read操作从主内存中得到的变量值放入到工作内存变量副本
use 作用于工作内存变量，把工作内存中的一个变量的值传递给执行引擎，每当jvm遇到一个需要使用到变量的值的字节码指令时会执行这个操作。
assign 作用于工作内存变量，把一个从执行引擎收到的值付给工作内存变量，每当jvm遇到一个给变量赋值的指字节码指令时执行这个操作。
store作用于工作内存变量，把工作内存中一个变量的值传给主存。
write作用于主存变量，把store操作从工作内存中得到的变量放入到主存变量中。

JMM还定义了执行上述八种操作必须满足的规则
1.不允许read和load 、store和write操作之一单独出现，也就是不允许一个变量从主存读取了但工作内存不接收，或者从工作内存发起了回写主存但主存不接收的情况出现
2.不允许一个线程丢弃他的最近的assign操作，也就是在工作内存中改变了之后必须把该变化同步回主内存
3.不允许一个线程没有发生过任何assign操作，就把数据从线程的工作内存同步回主存
4.一个新的变量只能在主存中诞生，不允许在工作内存中直接使用一个未被初始化(load或assign)的变量。也就是对一个变量实施的use和store操作之前，必须先执行过assign和load操作
5.一个变量在同一个时刻只允许一条线程对其进行lock操作，但lock操作可以被一条线程重复执行多次，多次lock后，只有执行相同次数的unlock操作变量才会被解锁
6.如果对一个变量执行lock操作，将会清空工作内存中此变量的值，在执行引擎使用这个变量前，需要重新执行load或assign操作初始化变量的值
7.如果一个变量实现没有被lock操作锁定，则不允许对他进行unlock操作；也不允许unlock一个被其他线程锁定主的变量
8.对一个变量执行unlock操作之前，必须先把此变量同步回主存，也就是执行store和write

3、先行发生原则 happens-before
Java语言中的先行发生原则在我们平时编码中平时没有怎么注意到，但这个原则非常重要，是判断线程是否安全的一个主要依据。
先行发生原则就是说：动作内部的偏序关系。线程A和线程B，如果A先行发生于B，那么A所带来的影响能够同步到B，也就是说能被B发觉。这里所谓的影响主要是指：共享变量的值。
这里的先行发生原则主要有下面几条：
**程序次序法则：**在同一个线程中，程序按照代码的书写顺序执行。写在前面的先执行，写在后面的后执行(这里要考虑流程控制语句)。
**监视器锁法则：**一个unlock操作先行发生于后面对同一个锁的lock操作。同一个锁，后面指的是时间上先后顺序
**volatile变量法则：**对被volatile修饰的变量，写操作先行发生与后续对同一个变量的读操作。
线程启动法则：线程对象的启动方法先行发生于此线程内部的每一个操作。
**线程终止法则：**线程对象中的所有操作都先行发生与线程的终止。
**线程中断法则：**对线程interrupt方法的调用先行发生于被中断线程的代码检测到中断事件的发生。
**对象终结法则：**一个对象的构造方法结束先行于它的finalize方法的开始。
传递性：如果A先行发生与B，B先行发生于C，那么A先行发生于C。

java无需任何同步手段保障就可以成立的规则。

private int value = 0;
public void setValue(int value){
	this.value = value;
}
public int getValue(){
	return value;
}

这是一段最普通的代码
假设线程A和线程B，线程A时间上先调用了setValue(1)，然后线程B后调用了同一个对象的getValue方法，那么线程B得到的结果是什么？

分析一下规则：
两个方法分别由线程A和B调用，不在一个线程中，所以程序次序规则不适用；没有同步块，自然没有lock和unlock操作，所以监视器锁法则不适用；由于value变量没有被volitale关键字修饰，所以volatile变量规则不适用；后面的法则完全扯不上关系。因此没有一个适用的先行发生规则，因此尽管线程A在时间上先于线程B，但无法确定线程B中getValue的值。
怎么修复呢？要么set get上加上synchronize，这样套用监视器锁法则，要么value定义为volitale，因为set方法修改value的值并不依赖这个值本身的值，这样套用volatile变量规则。

1.一个操作时间上的先发生不代表这个操作会是先行发生
2.一个操作是先行发生，也不代表这个操作是时间上先发生。因为有指令重排序。

衡量并发安全问题的时候不要受到时间顺序的干扰，一切必须以先行发生原则为准

4、不可变类
一个类是一个不可变类，那么这个类的方法就是安全的，不用加synchronized。无论多少线程访问都是安全的。比如String类，就是一个不可变类，它的所有方法就不用加锁。
我们来看一个案例：
定义一个类User。

public final class User {
	private final Integer id;
	private final String name;
	public User(Integer id, String name) {
		this.id = id;
		this.name = name;
	}
	public Integer getId() {
		return id;
	}
	public String getName() {
		return name;
	}
}

这个类的字段值id和name，只能通过构造方法来设置，没有set方法。这个时候即使有多个线程来访问，也是现成安全的。
User类被声明为final类，预防了定义它的子类修改字段的可能性。
User类的id和name声明为private ，这样只能在内部看到，预防了其他类修改它的值。
User类的id和name声明为final，保证了值不会发生改变。

如果User类修改为如下代码：

public final class User {
	private final Integer id;
	private final String name;
	private final StringBuilder address;
	public User(Integer id, String name, StringBuilder address) {
		this.id = id;
		this.name = name;
		this.address = address;
	}
	public Integer getId() {
		return id;
	}
	public String getName() {
		return name;
	}
	public StringBuilder getAddress() {
		return address;
	}
	
	
}

那么则不是现成安全的。因为getAddress方法会返回StringBuilder对象。而这个StringBuilder对象是一个引用对象，其他类获得了它的引用则就会修改它的值。
当对象的产生，状态不在改变；对象需要共享，访问比较频繁的时候，推荐使用不可变类来实现线程安全。

5、volatile关键字

volatile用途

volatile关键字是Java虚拟机中最轻量级的同步机制，它确保了对一个变量的更新在其他线程是可见的。当一个变量声明为volatile，编译器运行时会监视这个变量，读一个volatile变量总会返回某个线程写入的最新值。
除此之外，volatile变量可以禁止指令重排序优化。

**注意，对于volatile变量保证线程间的可见性，并不是说所有的情况就不需要加锁了，**在：
1.运算接果并不依赖变量的当前值
2.变量不需要与其他变量共同参与不变约束
这两种情况下是不用加锁的，其他还需要通过加锁来保证线程安全
示例代码：

/**
 * 测试volatile关键字
 */
public class TestVolatile {
	private volatile int i = 0;
	public void increase(){
		i++;
	}
	public void go(){
		for (int i = 0; i < 30; i++) {
			new Thread(new Runnable() {
				
				@Override
				public void run() {
					// TODO Auto-generated method stub
					for(int j = 0;j<10000;j++){
					increase();
					}
				}
			}).start();
		}
		while(Thread.activeCount()!=1){
			//什么都不做，等待前面所有线程运行完毕。只剩下main线程
		}
		System.out.println(i);
	}
	public static void main(String[] args) {
		new TestVolatile().go();
	}
}

这段代码发起了30个线程，每个线程对i变量自增10000次。while循环是在空等，等待30个线程全部完毕后打印变量i的值。只可惜每次输出的结果都小于300000。
这是因为不符合我们说的对volatile关键字的两条要求的第一条。
因为 i++并不是一个原子操作，i++实际是进行了多步操作的：
1.取得i的值。
2.将i的值取到操作栈的顶部
3.对i进行加操作
4.将i的值同步到主内存中。
很明显，多个线程进行这样的操作时，比如两个线程，A和B。
当A线程获取的i的值，推到操作栈顶部，这时候B线程修改了i的值，A线程的i值过期，实际应该更大，所以A线程对较小的i进行了加操作。重复多次，将远远小于300000这个数。

解决方案：

import java.util.concurrent.atomic.AtomicInteger;
/**
 * 成功执行加操作
 */
public class TestVolatileSolution {
	private  AtomicInteger i = new AtomicInteger(0);
	public void increase(){
		i.getAndIncrement();
	}
	public void go(){
		for (int i = 0; i < 30; i++) {
			new Thread(new Runnable() {
				
				@Override
				public void run() {
					// TODO Auto-generated method stub
					for(int j = 0;j<10000;j++){
					increase();
					}
				}
			}).start();
		}
		while(Thread.activeCount()!=1){
			//什么都不做，等待前面所有线程运行完毕。只剩下main线程
		}
		System.out.println(i);
	}
	public static void main(String[] args) {
		new TestVolatileSolution().go();
	}
}

volatile的另外一个功能，防止JVM指令重排优化。在一个线程中，所有代码按照书写的顺序执行，而在多线程中，一个线程看另外一个线程，则编码是乱序的。

六、公平锁和非公平锁

在java的锁机制中，公平和非公平的参考物是什么，个人而言觉得是相对产生的结果而立，简单的来说，如果一个线程组里，能保证每个线程都能拿到锁，那么这个锁就是公平锁。相反，如果保证不了每个线程都能拿到锁，也就是存在有线程饿死，那么这个锁就是非公平锁。本文围绕ReenTrantLock来讲。

实现原理
那如何能保证每个线程都能拿到锁呢，队列FIFO是一个完美的解决方案，也就是先进先出，java的ReenTrantLock也就是用队列实现的公平锁和非公平锁。
在公平的锁中，如果有另一个线程持有锁或者有其他线程在等待队列中等待这个所，那么新发出的请求的线程将被放入到队列中。而非公平锁上，只有当锁被某个线程持有时，新发出请求的线程才会被放入队列中（此时和公平锁是一样的）。所以，它们的差别在于非公平锁会有更多的机会去抢占锁。

公平锁：

 final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        if (!hasQueuedPredecessors() &&
            compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }

  #hasQueuedPredecessors的实现
    public final boolean hasQueuedPredecessors() {
   
        Node t = tail; // Read fields in reverse initialization order
        Node h = head;
        Node s;
        return h != t &&
            ((s = h.next) == null || s.thread != Thread.currentThread());
    }

非公平锁：

 final Thread current = Thread.currentThread();
        int c = getState();
        if (c == 0) {
            if (compareAndSetState(0, acquires)) {
                setExclusiveOwnerThread(current);
                return true;
            }
        }

示例
公平锁：

import java.util.concurrent.locks.ReentrantLock;
/**
 * Created by Fant.J.
 */
public class MyFairLock {
    /**
     *     true 表示 ReentrantLock 的公平锁
     */
    private  ReentrantLock lock = new ReentrantLock(true);

    public   void testFail(){
        try {
            lock.lock();
            System.out.println(Thread.currentThread().getName() +"获得了锁");
        }finally {
            lock.unlock();
        }
    }
    public static void main(String[] args) {
        MyFairLock fairLock = new MyFairLock();
        Runnable runnable = () -> {
            System.out.println(Thread.currentThread().getName()+"启动");
            fairLock.testFail();
        };
        Thread[] threadArray = new Thread[10];
        for (int i=0; i<10; i++) {
            threadArray[i] = new Thread(runnable);
        }
        for (int i=0; i<10; i++) {
            threadArray[i].start();
        }
    }
}

Thread-0启动
Thread-0获得了锁
Thread-1启动
Thread-1获得了锁
Thread-2启动
Thread-2获得了锁
Thread-3启动
Thread-3获得了锁
Thread-4启动
Thread-4获得了锁
Thread-5启动
Thread-5获得了锁
Thread-6启动
Thread-6获得了锁
Thread-8启动
Thread-8获得了锁
Thread-7启动
Thread-7获得了锁
Thread-9启动
Thread-9获得了锁

可以看到，获取锁的线程顺序正是线程启动的顺序。

非公平锁：

public class MyNonfairLock {
    /**
     *     false 表示 ReentrantLock 的非公平锁
     */
    private  ReentrantLock lock = new ReentrantLock(false);

    public  void testFail(){
        try {
            lock.lock();
            System.out.println(Thread.currentThread().getName() +"获得了锁");
        }finally {
            lock.unlock();
        }
    }
    public static void main(String[] args) {
        MyNonfairLock nonfairLock = new MyNonfairLock();
        Runnable runnable = () -> {
            System.out.println(Thread.currentThread().getName()+"启动");
            nonfairLock.testFail();
        };
        Thread[] threadArray = new Thread[10];
        for (int i=0; i<10; i++) {
            threadArray[i] = new Thread(runnable);
        }
        for (int i=0; i<10; i++) {
            threadArray[i].start();
        }
    }
}

Thread-1启动
Thread-0启动
Thread-0获得了锁
Thread-1获得了锁
Thread-8启动
Thread-8获得了锁
Thread-3启动
Thread-3获得了锁
Thread-4启动
Thread-4获得了锁
Thread-5启动
Thread-2启动
Thread-9启动
Thread-5获得了锁
Thread-2获得了锁
Thread-9获得了锁
Thread-6启动
Thread-7启动
Thread-6获得了锁
Thread-7获得了锁

可以看出非公平锁对锁的获取是乱序的，即有一个抢占锁的过程。

最后
那非公平锁和公平锁适合什么场合使用呢，他们的优缺点又是什么呢？

优缺点：
非公平锁性能高于公平锁性能。首先，在恢复一个被挂起的线程与该线程真正运行之间存在着严重的延迟。而且，非公平锁能更充分的利用cpu的时间片，尽量的减少cpu空闲的状态时间。

使用场景
使用场景的话呢，其实还是和他们的属性一一相关，举个栗子：如果业务中线程占用(处理)时间要远长于线程等待，那用非公平锁其实效率并不明显，但是用公平锁会给业务增强很多的可控制性。