「java同步原理」java的同步机制
本篇文章给大家谈谈java同步原理，以及java的同步机制对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。
本文目录一览：
Java类的实例化顺序是什么样的?Java线程同步的方式有哪些?
引言：java是在1990年初 ，被詹姆斯•高斯林等人开发的一门面向对象的编程语言。起初，java被称为0ak，来经过发展0ak改名为java，与1995年的五月份正式向大家发布。
一、java类的实例化顺序
java的实例化顺序在继承没有的情况
单独一个类的场景下，初始化顺序为依次为静态数据，继承的基类的构造函数，成员变量，被调用的构造函数。
其中静态数据只会初始化一次。（静态数据包括静态代码块和静态变量，每个类的静态数据只会初始化一次）
在继承的情况下
添加两个基类，让继承父亲，父亲继承祖父。
继承的情况就比较复杂了。由继承了基类，还将往上回溯，递归地调用基类的无参构造方法。
在我们的例子中，在初始化静态数据后，会先往上追溯，调用父的默认构造方法，此时再往上追溯到爷爷的默认构造方法。
二、信息技术的不断发展
java也体现了现代社会下信息技术的不断发展，科技水平的不断进步，人们的工作也越来越便利，日常生活也越来越方便，越来越多的工具被人们所开发应用 。科技的发展也要求我们掌握更多的知识，在探索的过程中，我们需要明白更方便的方法使用更便捷的方法来取得成就，我的方法会让过程事半功倍。科技的发展也要求我们掌握越来越多的知识，我们可以通过学习来获得更多的知识，来帮助我们在以后的工作生活，多些技能总是有好处的 。
无论是java还是什么别的东西他都体现了现代社会与信息技术的不断发展，人们在进行进行技术开发时也有了越来越多的方法。程序类的工作也有了更为快捷的方法，这为信息技术的发展也提供了更好的发展方法
java类内多个函数如何同步
线程间的通讯首要的方式就是对字段及其字段所引用的对象的共享访问。这种通信方式是及其高效的，但是也是导致了可能的错误：线程间相互干涉和内存一致性的问题。避免出现这两种错误的方法就是同步。
线程间相互干扰描述了当多个线程访问共享数据时可能出现的错误。
内存一致性错误描述的了共享内存可能导致的错误。
同步方法（Synchronized method）描述了一种简单的可以有效防止线程间相互干扰及其内存一致性错误的方法。
明锁及同步描述了一种更加通用的同步方法，以及同步是如何基于明锁而实现的。
原子性描述了不能被其它线程干扰的操作。
线程间的相互干扰
考虑下面的一个简单的类Counter：
[java] view plaincopy
class Counter {
private int c = 0;
public void increment() {
c++;
}
public void decrement() {
c--;
}
public int value() {
return c;
}
}
不难看出，其中的increment()方法用来对c加1；decrement()方法用来对c减1。然而，有多个线程中都存在对某个Counter对象的引用，那么线程间的干扰就可能导致出现我们不想要的结果。
线程间的干扰出现在多个线程对同一个数据进行多个操作的时候，也就是出现了“交错”。这就意味着操作是由多个步骤构成的，而此时，在这多个步骤的执行上出现了叠加。
Counter类对象的操作貌似不可能出现这种“交错”，因为其中的两个关于c的操作都很简单，只有一条语句。然而，即使是一条语句也是会被VM翻译成多个步骤的。在这里，我们不深究VM具体上上面的操作翻译成了什么样的步骤。只需要知道即使简单的c++这样的表达式也是会被翻译成三个步骤的：
1. 获取c的当前值。
2. 对其当前值加1。
3. 将增加后的值存储到c中。
表达式c--也是会被按照同样的方式进行翻译，只不过第二步变成了减1，而不是加1。
假定线程A中调用increment方法，线程B中调用decrement方法，而调用时间基本上相同。如果c的初始值为0，那么这两个操作的“交错”顺序可能如下：
1. 线程A：获取c的值。
2. 线程B：获取c的值。
3. 线程A：对获取到的值加1；其结果是1。
4. 线程B：对获取到的值减1；其结果是-1。
5. 线程A：将结果存储到c中；此时c的值是1。
6. 线程B：将结果存储到c中；此时c的值是-1。
这样线程A计算的值就丢失了，也就是被线程B的值覆盖了。上面的这种“交错”只是一种可能性。在不同的系统环境中，有可能是B线程的结果丢失了，或者是根本就不会出现错误。由于这种“交错”是不可预测的，线程间相互干扰造成的缺陷是很难定位和修改的。
内存一致性错误
内存一致性错误发生在不同线程对同一数据产生不同的“见解”。导致内存一致性错误的原因很负责，超出了本文的描述范围。庆幸的是，程序员并不需要知道出现这些原因的细节。我们需要的只是一种可以避免这种错误的方法。
避免出现内存一致性错误的关键在于理解“先后顺序”关系。这种关系是一种简单的方法，能够确保一条语句对内存的写操作对于其它特定的语句都是可见的。为了理解这点，我们可以考虑如下的示例。假定定义了一个简单的int类型的字段并对其进行了初始化：
int counter = 0;
该字段由两个线程共享：A和B。假定线程A对counter进行了自增操作：
counter++;
然后，线程B输出counter的值：
System.out.println(counter);
如果以上两条语句是在同一个线程中执行的，那么输出的结果自然是1。但是如果这两条语句是在两个不同的线程中，那么输出的结构有可能是0。这是因为没有保证线程A对counter的修改对线程B来说是可见的。除非程序员在这两条语句间建立了一定的“先后顺序”。
我们可以采取多种方式建立这种“先后顺序”。使用同步就是其中之一，这点我们将会在下面的小节中看到。
到目前为止，我们已经看到了两种建立这种“先后顺序”的方式：
当一条语句中调用了Thread.start()方法，那么每一条和该语句已经建立了“先后顺序”的语句都和新线程中的每一条语句有着这种“先后顺序”。引入并创建这个新线程的代码产生的结果对该新线程来说都是可见的。
当一个线程终止了并导致另外的线程中调用join的语句回，那么此时这个终止了的线程中执行了的所有语句都和随后的join语句随后的所有语句建立了这种“先后关系”。也就是说终止了的线程中的代码效果对调用join方法的线程来说是可见。
关于哪些操作可以建立这种“先后关系”，更多的信息请参阅“java.util.concurrent包的概要说明”。
同步方法
Java编程语言中提供了两种基本的同步用语：同步方法和同步语句。同步语句相对而言更为复杂一些，我们将在下一小节中进行描述。本节重点讨论同步方法。
我们只需要在声明方法的时候增加关键字synchronized即可：
[java] view plaincopy
public class SynchronizedCounter {
private int c = 0;
public synchronized void increment() {
c++;
}
public synchronized void decrement() {
c--;
}
public synchronized int value() {
return c;
}
}
如果count 是SynchronizedCounter类的实例，设置其方法为同步方法将有一下两个效果：
首先，不可能出现对同一对象的同步方法的两个调用的“交错”。当一个线程在执行一个对象的同步方式的时候，其他所有的调用该对象的同步方法的线程对会被挂起，直到第一个线程对该对象操作完毕。
其次，当一个同步方法退出时，会自动与该对象的后续同步方法间建立“先后顺序”的关系。这就确保了对该对象的修改对其他线程是可见的。
注意：构造函数不能为同步的——在构造函数前使用synchronized关键字将导致语义错误。同步构造函数是没有意义的。这是因为只有创建该对象的线程才能调用其构造函数。
警告：在创建多个线程共享的对象时，要特别小心对该对象的引用不能过早地“泄露”。例如，假定我们想要维护一个保存类的所有实例的列表instances。我们可能会在构造函数中这样写到：
instances.add(this);
但是，其他线程可会在该对象的构造完成之前就访问该对象。
同步方法是一种简单的可以避免线程相互干扰和内存一致性错误的策略：如果一个对象对多个线程都是可见的，那么所有对该对象的变量的读写都应该是通过同步方法完成的（一个例外就是final字段，他在对象创建完成后是不能被修改的，因此，在对象创建完毕后，可以通过非同步的方法对其进行安全的读取）。这种策略是有效的，但是可能导致“liveness”问题。这点我们会在本课程的后面进行描述。
内部锁及同步
同步是构建在被称为“内部锁或者是监视锁”的内部实体上的。（在API中通常被称为是“监视器”。）内部锁在两个方面都扮演着重要的角色：保证对对象访问的排他性和建立也对象可见性相关的重要的“先后顺序”。
每一个对象都有一个与之相关联动的内部锁。按照传统的做法，当一个线程需要对一个对象的字段进行排他性访问并保持访问的一致性时，他必须在访问前先获取该对象的内部锁，然后才能访问之，最后释放该内部锁。在线程获取对象的内部锁到释放对象的内部锁的这段时间，我们说该线程拥有该对象的内部锁。只要有一个线程已经拥有了一个内部锁，其他线程就不能在拥有该锁了。其他线程将会在试图获取该锁的时候被阻塞了。
当一个线程释放了一个内部锁，那么就会建立起该动作和后续获取该锁之间的“先后顺序”。
同步方法中的锁
当一个线程调用一个同步方法的时候，他就自动地获得了该方法所属对象的内部锁，并在方法返回的时候释放该锁。即使是由于出现了没有被捕获的异常而导致方法返回，该锁也会被释放。
我们可能会感到疑惑：当调用一个静态的同步方法的时候会怎样了，静态方法是和类相关的，而不是和对象相关的？ 在这种情况下，线程获取的是该类的类对象的内部锁。这样对于静态字段的方法是通过一个和类的实例的锁相区分的另外的锁来进行的。
同步语句
另外一种创建同步代码的方式就是使用同步语句。和同步方法不同，使用同步语句是必须指明是要使用哪个对象的内部锁：
[java] view plaincopy
public void addName(String name) {
synchronized(this) {
lastName = name;
nameCount++;
}
nameList.add(name);
}
在上面的示例中，方法addName需要对lastName和nameCount的修改进行同步，还要避免同步调用其他对象的方法（在同步代码段中调用其他对象的方法可能导致“Liveness”中描述的问题）。如果没有使用同步语句，那么将不得不使用一个单独的，未同步的方法来完成对nameList.add的调用。
在改善并发性时，巧妙地使用同步语句能起到很大的帮助作用。例如，我们假定类MsLunch有两个实例字段，c1和c2，这两个变量绝不会一起使用。所有对这两个变量的更新都需要进行同步。但是没有理由阻止对c1的更新和对c2的更新出现交错——这样做会创建不必要的阻塞，进而降低并发性。此时，我们没有使用同步方法或者使用和this相关的锁，而是创建了两个单独的对象来提供锁。
[java] view plaincopy
public class MsLunch {
private long c1 = 0;
private long c2 = 0;
private Object lock1 = new Object();
private Object lock2 = new Object();
public void inc1() {
synchronized(lock1) {
c1++;
}
}
public void inc2() {
synchronized(lock2) {
c2++;
}
}
}
采用这种方式时需要特别的小心。我们必须绝对确保相关字段的访问交错是完全安全的。
同步的重入
回忆前面提到的：线程不能获取已经被别的线程获取的锁。单丝线程可以获取自身已经拥有的锁。允许一个线程能重复获得同一个锁就称为同步重入。它是这样的一种情况：在同步代码中直接或者间接地调用了还有同步代码的方法，两个同步代码段中使用的是同一个锁。如果没有同步重入，在编写同步代码时需要额外的小心，以避免线程将自己阻塞。
原子性
在编程中，原子性动作就是指一次性有效完成的动作。原子性动作是不能在中间停止的：要么一次性完全执行完毕，要么就不执行。在动作没有执行完毕之前，是不会产生可见结果的。
通过前面的示例，我们已经发现了诸如c++这样的自增表达式并不属于原子操作。即使是非常见到的表达式也定义了负责的动作，这些动作可以被解释成许多别的动作。然而，的确存在一些原子操作的：
对几乎所有的原生数据类型变量的读写（除了long和都变了外）以及引用变量的读写都是原子的。
对所有声明为volatile的变量的读写都是原子的，包括long和double类型。
原子性动作是不会出现交错的，因此，使用这些原子性动作时不用考虑线程间的干扰。然而，这并不意味着可以移除对原子操作的同步。因为内存一致性错误还是有可能出现的。使用volatile变量可以减少内存一致性错误的风险，因为任何对volatile变量的写操作都和后续对该变量的读操作建立了“先后顺序”。这就意味着对volatile类型变量的修改对于别的线程来说是可见的。更重要的是，这意味着当一个线程读取一个volatile类型的变量是，他看到的不仅仅是对该变量的最后一次修改，还看到了导致这种修改的代码带来的其他影响。
使用简单的原子变量访问比通过同步代码来访问变量更高效，但是需要程序员的更多细心考虑，以避免内存一致性错误。这种额外的付出是否值得完全取决于应用程序的大小和复杂度。
在包java.util.concurrent中的一些类提供了原子方法，这些方法不依赖于同步。我们会在章节：High Level Concurrency Objects中进行讨论。
java多线程有几种实现方法？线程之间如何同步
一、为什么要线程同步
因为当我们有多个线程要同时访问一个变量或对象时，如果这些线程中既有读又有写操作时，就会导致变量值或对象的状态出现混乱，从而导致程序异常。举个例子，如果一个银行账户同时被两个线程操作，一个取100块，一个存钱100块。假设账户原本有0块，如果取钱线程和存钱线程同时发生，会出现什么结果呢？取钱不成功，账户余额是100.取钱成功了，账户余额是0.那到底是哪个呢？很难说清楚。因此多线程同步就是要解决这个问题。
二、不同步时的代码
Bank.Java
package threadTest;
/**
* @author ww
*
*/
public class Bank {
private int count =0;//账户余额
//存钱
public void addMoney(int money){
count +=money;
System.out.println(System.currentTimeMillis()+"存进："+money);
}
//取钱
public void subMoney(int money){
if(count-money 0){
System.out.println("余额不足");
return;
}
count -=money;
System.out.println(+System.currentTimeMillis()+"取出："+money);
}
//查询
public void lookMoney(){
System.out.println("账户余额："+count);
}
}
SyncThreadTest.java
package threadTest;
public class SyncThreadTest {
public static void main(String args[]){
final Bank bank=new Bank();
Thread tadd=new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
while(true){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
bank.addMoney(100);
bank.lookMoney();
System.out.println("\n");
}
}
});
Thread tsub = new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
while(true){
bank.subMoney(100);
bank.lookMoney();
System.out.println("\n");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
});
tsub.start();
tadd.start();
}
}
余额不足
账户余额：0
余额不足
账户余额：100
1441790503354存进：100
账户余额：100
1441790504354存进：100
账户余额：100
1441790504354取出：100
账户余额：100
1441790505355存进：100
账户余额：100
1441790505355取出：100
账户余额：100
三、使用同步时的代码
（1）同步方法：
即有synchronized关键字修饰的方法。 由于java的每个对象都有一个内置锁，当用此关键字修饰方法时，内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。
修改后的Bank.java
package threadTest;
/**
* @author ww
*
*/
public class Bank {
private int count =0;//账户余额
//存钱
public synchronized void addMoney(int money){
count +=money;
System.out.println(System.currentTimeMillis()+"存进："+money);
}
//取钱
public synchronized void subMoney(int money){
if(count-money 0){
System.out.println("余额不足");
return;
}
count -=money;
System.out.println(+System.currentTimeMillis()+"取出："+money);
}
//查询
public void lookMoney(){
System.out.println("账户余额："+count);
}
}
再看看运行结果：
余额不足
账户余额：0
余额不足
账户余额：0
1441790837380存进：100
账户余额：100
1441790838380取出：100
账户余额：0
1441790838380存进：100
账户余额：100
1441790839381取出：100
账户余额：0
瞬间感觉可以理解了吧。
注： synchronized关键字也可以修饰静态方法，此时如果调用该静态方法，将会锁住整个类
（2）同步代码块
即有synchronized关键字修饰的语句块。被该关键字修饰的语句块会自动被加上内置锁，从而实现同步
Bank.java代码如下：
package threadTest;
/**
* @author ww
*
*/
public class Bank {
private int count =0;//账户余额
//存钱
public void addMoney(int money){
synchronized (this) {
count +=money;
}
System.out.println(System.currentTimeMillis()+"存进："+money);
}
//取钱
public void subMoney(int money){
synchronized (this) {
if(count-money 0){
System.out.println("余额不足");
return;
}
count -=money;
}
System.out.println(+System.currentTimeMillis()+"取出："+money);
}
//查询
public void lookMoney(){
System.out.println("账户余额："+count);
}
}
运行结果如下：
余额不足
账户余额：0
1441791806699存进：100
账户余额：100
1441791806700取出：100
账户余额：0
1441791807699存进：100
账户余额：100
效果和方法一差不多。
注：同步是一种高开销的操作，因此应该尽量减少同步的内容。通常没有必要同步整个方法，使用synchronized代码块同步关键代码即可。
（3）使用特殊域变量(volatile)实现线程同步
a.volatile关键字为域变量的访问提供了一种免锁机制
b.使用volatile修饰域相当于告诉虚拟机该域可能会被其他线程更新
c.因此每次使用该域就要重新计算，而不是使用寄存器中的值
d.volatile不会提供任何原子操作，它也不能用来修饰final类型的变量
Bank.java代码如下：
package threadTest;
/**
* @author ww
*
*/
public class Bank {
private volatile int count = 0;// 账户余额
// 存钱
public void addMoney(int money) {
count += money;
System.out.println(System.currentTimeMillis() + "存进：" + money);
}
// 取钱
public void subMoney(int money) {
if (count - money 0) {
System.out.println("余额不足");
return;
}
count -= money;
System.out.println(+System.currentTimeMillis() + "取出：" + money);
}
// 查询
public void lookMoney() {
System.out.println("账户余额：" + count);
}
}
运行效果怎样呢？
余额不足
账户余额：0
余额不足
账户余额：100
1441792010959存进：100
账户余额：100
1441792011960取出：100
账户余额：0
1441792011961存进：100
账户余额：100
是不是又看不懂了，又乱了。这是为什么呢？就是因为volatile不能保证原子操作导致的，因此volatile不能代替synchronized。此外volatile会组织编译器对代码优化，因此能不使用它就不适用它吧。它的原理是每次要线程要访问volatile修饰的变量时都是从内存中读取，而不是存缓存当中读取，因此每个线程访问到的变量值都是一样的。这样就保证了同步。
（4）使用重入锁实现线程同步
在JavaSE5.0中新增了一个java.util.concurrent包来支持同步。ReentrantLock类是可重入、互斥、实现了Lock接口的锁， 它与使用synchronized方法和快具有相同的基本行为和语义，并且扩展了其能力。
ReenreantLock类的常用方法有：
ReentrantLock() : 创建一个ReentrantLock实例
lock() : 获得锁
unlock() : 释放锁
注：ReentrantLock()还有一个可以创建公平锁的构造方法，但由于能大幅度降低程序运行效率，不推荐使用
Bank.java代码修改如下：
package threadTest;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* @author ww
*
*/
public class Bank {
private int count = 0;// 账户余额
//需要声明这个锁
private Lock lock = new ReentrantLock();
// 存钱
public void addMoney(int money) {
lock.lock();//上锁
try{
count += money;
System.out.println(System.currentTimeMillis() + "存进：" + money);
}finally{
lock.unlock();//解锁
}
}
// 取钱
public void subMoney(int money) {
lock.lock();
try{
if (count - money 0) {
System.out.println("余额不足");
return;
}
count -= money;
System.out.println(+System.currentTimeMillis() + "取出：" + money);
}finally{
lock.unlock();
}
}
// 查询
public void lookMoney() {
System.out.println("账户余额：" + count);
}
}
运行效果怎么样呢？
余额不足
账户余额：0
余额不足
账户余额：0
1441792891934存进：100
账户余额：100
1441792892935存进：100
账户余额：200
1441792892954取出：100
账户余额：100
效果和前两种方法差不多。
如果synchronized关键字能满足用户的需求，就用synchronized，因为它能简化代码 。如果需要更高级的功能，就用ReentrantLock类，此时要注意及时释放锁，否则会出现死锁，通常在finally代码释放锁
（5）使用局部变量实现线程同步
Bank.java代码如下：
package threadTest;
/**
* @author ww
*
*/
public class Bank {
private static ThreadLocalInteger count = new ThreadLocalInteger(){
@Override
protected Integer initialValue() {
// TODO Auto-generated method stub
return 0;
}
};
// 存钱
public void addMoney(int money) {
count.set(count.get()+money);
System.out.println(System.currentTimeMillis() + "存进：" + money);
}
// 取钱
public void subMoney(int money) {
if (count.get() - money 0) {
System.out.println("余额不足");
return;
}
count.set(count.get()- money);
System.out.println(+System.currentTimeMillis() + "取出：" + money);
}
// 查询
public void lookMoney() {
System.out.println("账户余额：" + count.get());
}
}
运行效果：
余额不足
账户余额：0
余额不足
账户余额：0
1441794247939存进：100
账户余额：100
余额不足
1441794248940存进：100
账户余额：0
账户余额：200
余额不足
账户余额：0
1441794249941存进：100
账户余额：300
看了运行效果，一开始一头雾水，怎么只让存，不让取啊？看看ThreadLocal的原理：
如果使用ThreadLocal管理变量，则每一个使用该变量的线程都获得该变量的副本，副本之间相互独立，这样每一个线程都可以随意修改自己的变量副本，而不会对其他线程产生影响。现在明白了吧，原来每个线程运行的都是一个副本，也就是说存钱和取钱是两个账户，知识名字相同而已。所以就会发生上面的效果。
ThreadLocal与同步机制
a.ThreadLocal与同步机制都是为了解决多线程中相同变量的访问冲突问题
b.前者采用以"空间换时间"的方法，后者采用以"时间换空间"的方式
关于java同步原理和java的同步机制的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。
发布于：2023-01-10，除非注明，否则均为原创文章，转载请注明出处。