java学习初探十八之线程的线程同步_锁机制_synchronized

最新推荐文章于 2019-05-11 22:05:33 发布
最新推荐文章于 2019-05-11 22:05:33 发布
阅读量247 收藏
点赞数
分类专栏： java学习笔记 文章标签： java 线程 安全 sychronize
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lk2013/article/details/78867201
版权

一、线程同步
异步线程模型：t1线程执行t1的，t2线程执行t2的，两个线程之间谁也不等谁。
同步线程模型：t1线程和t2线程执行，当t1线程必须等t2线程执行结束之后，t1线程才能执行。

什么时候要同步？为什么要引入线程同步？
1.为了数据的安全。尽管应用程序的使用率降低，但是为了保证数据是安全的，必须加入线程同步机制。线程同步机制使程序变成了（等同）单线程
2.什么情况下要使用线程同步？
第一、必须是多线程环境；
第二、多线程环境共享同一个数据；
第三、共享数据涉及修改操作。

1.以下例子为没使用线程同步的情况：

package xiancheng2;
/*
 * 以下程序演示取款离职。以下程序不使用线程同步机制，
 * 多线程同时对同一个账号进行取款操作，会出现什么问题？
 */
public class ThreadTest1 {
    public static void main(String[] args) {
        //创建公共账号
        Account act=new Account("actno-001",5000);

        //创建线程对同一个账号取款
        Proccessor p=new Proccessor(act);

        Thread t1=new Thread(p);

        Thread t2=new Thread(p);

        t1.start();
        t2.start();
    }
}
//取款线程
class Proccessor implements Runnable{
    //账号
    Account act;
    public Proccessor(Account act) {
        this.act=act;
    }
    public void run() {
        act.withdraw(1000.0);
        System.out.println("取款成功，余额"+act.getBalance());
    }
}

//账号
class Account{
    private String actno;
    private double balance;
    public Account() {}
    public Account(String actno,double balance) {
        this.balance=balance;
        this.actno=actno;
    }
    public String getActno() {
        return actno;
    }
    public void setActno(String actno) {
        this.actno = actno;
    }
    public double getBalance() {
        return balance;
    }
    public void setBalance(double balance) {
        this.balance = balance;
    }
    //对外提供一个取款方法
    public void withdraw(double money) {//对当前账号进行取款操作
        double after=this.balance-money;
        //延迟
        try {Thread.sleep(5000);} catch (Exception e) { e.printStackTrace();    }
        //更新
        this.setBalance(after);
    }
}

输出：

取款成功，余额4000.0
取款成功，余额4000.0

显而易见，这是不正确的。
2.以下程序使用线程机制控制(synchronized)：

package xiancheng2;
/*
 * 以下程序演示取款离职。以下程序使用线程同步机制，
 * 多线程同时对同一个账号进行取款操作，会出现什么问题？
 */
public class ThreadTest1 {
    public static void main(String[] args) {
        //创建公共账号
        Account act=new Account("actno-001",5000);

        //创建线程对同一个账号取款
        Proccessor p=new Proccessor(act);

        Thread t1=new Thread(p);

        Thread t2=new Thread(p);

        t1.start();
        t2.start();
    }
}
//取款线程
class Proccessor implements Runnable{
    //账号
    Account act;
    public Proccessor(Account act) {
        this.act=act;
    }
    public void run() {
        act.withdraw(1000.0);
        System.out.println("取款成功，余额"+act.getBalance());
    }
}

//账号
class Account{
    private String actno;
    private double balance;
    public Account() {}
    public Account(String actno,double balance) {
        this.balance=balance;
        this.actno=actno;
    }
    public String getActno() {
        return actno;
    }
    public void setActno(String actno) {
        this.actno = actno;
    }
    public double getBalance() {
        return balance;
    }
    public void setBalance(double balance) {
        this.balance = balance;
    }
    //对外提供一个取款方法
    public void withdraw(double money) {//对当前账号进行取款操作

        //把需要同步的代码，放到同步语句块中。
        synchronized (this) {//填共享对象
            double after=this.balance-money;
            //延迟
            try {Thread.sleep(5000);} catch (Exception e) { e.printStackTrace();    }
            //更新
            this.setBalance(after);
        }

    }
}

输出：

取款成功，余额4000.0
取款成功，余额3000.0

3.执行原理：
t1线程执行到此处，遇到，synchronized关键字，就会去找this的对象锁。如果找到this对象锁，则进入同步语句块中执行程序。当同步语句块中的语句块执行结束后，t1线程归还this的对象锁。

在t1线程执行同步语句块的过程中，如果t2线程也过来执行，也遇到synchronized关键字，所以也去找this的对象锁，但是该对象锁被t1线程所有，只能在这等待this对象的归还。

sychronized关键字添加到成员方法上，线程拿走的也是this的对象锁。

package xiancheng2;
/*
 * 以下程序演示取款离职。以下程序不使用线程同步机制，
 * 多线程同时对同一个账号进行取款操作，会出现什么问题？
 */
public class ThreadTest1 {
    public static void main(String[] args) {
        //创建公共账号
        Account act=new Account("actno-001",5000);

        //创建线程对同一个账号取款
        Proccessor p=new Proccessor(act);

        Thread t1=new Thread(p);

        Thread t2=new Thread(p);

        t1.start();
        t2.start();
    }
}
//取款线程
class Proccessor implements Runnable{
    //账号
    Account act;
    public Proccessor(Account act) {
        this.act=act;
    }
    public void run() {
        act.withdraw(1000.0);
        System.out.println("取款成功，余额"+act.getBalance());
    }
}

//账号
class Account{
    private String actno;
    private double balance;
    public Account() {}
    public Account(String actno,double balance) {
        this.balance=balance;
        this.actno=actno;
    }
    public String getActno() {
        return actno;
    }
    public void setActno(String actno) {
        this.actno = actno;
    }
    public double getBalance() {
        return balance;
    }
    public void setBalance(double balance) {
        this.balance = balance;
    }
    //对外提供一个取款方法
    public synchronized void withdraw(double money) {//对当前账号进行取款操作
            double after=this.balance-money;
            //延迟
            try {Thread.sleep(5000);} catch (Exception e) { e.printStackTrace();    }
            //更新
            this.setBalance(after);
    }
}

为了精确控制，2的添加方法更适合些。

4.面试题

package xiancheng2;
/*
 * 面试题
 * t1线程没有结束的时候，t2需不需要等t1结束？
 * 答案：不需要。
 * 因为m2方法上没有synchronized，所以不需要找对象锁。
 * 如果m2方法上加了synchronized，则需要找对象锁，等待m1方法结束，释放对象锁。
 * 注意：t1、t2一定要共享同一个对象，才能谈同步机制。
 */
public class ThreadTest2 {
    public static void main(String[] args) throws InterruptedException {
        MyClass mc=new MyClass();
        myThread thread=new myThread(mc);

        Thread t1=new Thread(thread);
        t1.setName("t1");
        Thread t2=new Thread(thread);
        t2.setName("t2");

        //启动线程
        t1.start();

        //延迟保证t1线程先启动，并执行run
        Thread.sleep(1000);
        t2.start();

    }
}
class myThread implements Runnable{
    MyClass mc;
    myThread(MyClass mc){
        this.mc=mc;
    }
    public void run() {
        if(Thread.currentThread().getName().equals("t1")) {
            mc.m1();
        }
        if(Thread.currentThread().getName().equals("t2")) {
            mc.m2();
        }
    }
}
class MyClass{
    public synchronized void m1() {
        //休眠10s
        try{Thread.sleep(10000);}catch (InterruptedException e) {}
        System.out.println("m1........");
    }
    public void m2() {
        System.out.println("m2........");
    }
}

输出结果：

m2........
m1........

5.类锁 ，修饰静态方法

package xiancheng2;
/*
 * 类锁，类只有一个，所以锁是类级别的，只有一个
 */
public class ThreadTest3 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1=new Thread(new Proccessor());
        t1.setName("t1");
        Thread t2=new Thread(new Proccessor());
        t2.setName("t2");
        t1.start();
        Thread.sleep(1000);
        t2.start();
    }
}
class Proccessor implements Runnable{
    public void run() {
        if("t1".equals(Thread.currentThread().getName())) {
            Myclass.m1();
        }
        if("t2".equals(Thread.currentThread().getName())) {
            Myclass.m2();
        }
    }
}
class Myclass{
    //synchronized添加到静态方法上，线程执行此方法的时候会找类锁
    public synchronized static void m1() {
        try {
            Thread.sleep(10000);
        } catch (Exception e) {
        }
        System.out.println("m1.......");
    }
    //不会等m1结束，因为该方法没有被sychronized修饰。
    /*public static void m2() {
        System.out.println("m2.......");
    }
    */
    //会等m1结束，因为该方法没有被sychronized修饰。线程执行该代码需要“类锁”，而类锁只有一个
    public synchronized static void m2() {
        System.out.println("m2.......");
    }
}

6.死锁

package xiancheng2;
/*
 * 死锁
 */
public class ThreadTest1 {
    public static void main(String[] args) {
        Object o1=new Object();
        Object o2=new Object();

        Thread t1=new Thread(new T1(o1,o2));
        Thread t2=new Thread(new T2(o1,o2));
        t1.start();
        t2.start();

    }
}
class T1 implements Runnable{
    Object o1;
    Object o2;
    T1(Object o1,Object o2){
        this.o1=o1;
        this.o2=o2;
    }
    public void run() {
        //先锁o1,再锁o2
        synchronized (o1) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("t11....");
            synchronized (o2) {
                System.out.println("t1....");
            }
        }
    }
}
class T2 implements Runnable{
    Object o1;
    Object o2;
    T2(Object o1,Object o2){
        this.o1=o1;
        this.o2=o2;
    }
    public void run() {
        //先锁o2,再锁o1
        synchronized (o2) {
            try {
                Thread.sleep(1000);
            } catch (Exception e) {
            }
            System.out.println("t22....");
            synchronized (o1) {
                System.out.println("t2....");
            }
        }
    }
}
温暖的小柯南
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java 多线程同步 锁机制与synchronized深入解析
09-05
从尺寸上讲，同步代码块比同步方法小。你可以把同步代码块看成是没上锁房间里的一块用带锁的屏风隔开的空间
Java中锁机制Synchronized方法说明
guyun_shine的专栏
08-18 541
再来看看同步代码块。和同步方法有小小的不同。 　　1.从尺寸上讲，同步代码块比同步方法小。你可以把同步代码块看成是没上锁房间里的一块用带锁的屏风隔开的空间。 　　2.同步代码块还可以人为的指定获得某个其它对象的key。就像是指定用哪一把钥匙才能开这个屏风的锁，你可以用本房的钥
Java 线程同步与互斥，线程安全，Java锁
ShareUs的专栏
05-13 6953
多线程三个特征：原子性、可见性以及有序性. 同步锁 /并发锁/ 读写锁，显示锁， ReentrantLock与Condition.> 线程的同步与互斥（同步线程与异步线程，线程同步和异步问题） Java 虚拟机中的同步(Synchronization)基于进入和退出管程(Monitor)对象实现， 无论是显式同步(有明确的 monitorenter 和 monitorexit 指令,即同...
Win32的多线程技术，对DirectShow有一些用处
lserlohn的专栏
03-18 1881
有关多线程的一些技术问题：1、  何时使用多线程？2、  线程如何同步？3、  线程之间如何通讯？4、  进程之间如何通讯？先来回答第一个问题，线程实际主要应用于四个主要领域，当然各个领域之间不是绝对孤立的，他们有可能是重叠的，但是每个程序应该都可以归于某个领域：1、  offloading time-consuming task。由辅助线程来执行耗时计算，而使GUI有更好的反应。我想这应该是我们
Java线程同步、锁机制精解（5中同步方式）
LXChild的专栏
11-17 1357
为什么需要同步 java允许多线程并发控制，当多个线程同时操作一个可共享的资源变量时（如数据的增删改查），将会导致数据不准确，相互之间产生冲突，因此加入同步锁以避免在该线程没有完成操作之前，被其他线程的调用，从而保证了该变量的唯一性和准确性。 同步方式 synchronized同步方法 synchronized同步代码块 volatile特殊域变量 ReenreantLock重入锁 Thread
线程间同步机制----读写锁
Denkensk的专栏
12-25 1159
一、读写锁基本原理 读写锁与互斥锁类似，不过读写锁运行更高的并行。互斥量要么锁住状态，要么就是不加锁状态，而且一次只有一个线程可以对其加锁。读写锁可以有3中状态：读模式下加锁状态，写模式下加锁状态，不加锁状态。一次只有一个线程可以占有写模式的读写锁，但是多个线程可以同时占有读模式的读写锁。 (1)当读写锁是写加锁状态时，在这个锁被解锁之前，所有试图对这个锁加锁的进程都会被阻塞。 (2
java多线程编程之使用Synchronized块同步方法
09-04
synchronized块来同步一个对象变量,也可以使用synchronized块来同步类中的静态方法和非静态方法,下面使用Synchronized块同步方法
java多线程编程之使用Synchronized关键字同步类方法
09-04
JAVA中要想解决“脏数据”的问题，最简单的方法就是使用synchronized关键字来使run方法同步,看下面的代码，只要在void和public之间加上synchronized关键字
Java线程之线程同步synchronized和volatile详解
08-28
主要介绍了Java线程之线程同步synchronized和volatile详解，具有一定参考价值，需要的朋友可以了解下。
java多线程编程之Synchronized块同步方法
09-03
主要介绍了java多线程编程之Synchronized块同步方法，synchronized关键字又称同步锁，当方法执行完后，会自动释放锁锁，只有一个线程能进入此方法，看看下文中各种例子对synchronized的详细解释
多线程中的锁机制
热门推荐
是蛋筒啊的博客
08-04 2万+
由于多线程之间是并发执行的，而系统调度又是随机的，因此在写多线程程序时会出现很多问题，这时就免不了要用到各种锁机制来保证线程安全且按我们的意愿正确执行。 互斥锁 1.定义一个互斥量 pthread_mutex_t mutex; 2.初始化互斥量 静态分配 pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZED 动态分配 int...
java多线程中两种锁机制
在下鲨鱼，有何贵干
03-01 1498
java包含两种锁机制：synchronized和java.util.concurrent.LockLock接口实现类：ReenTrantLock锁的种类：1.可重入锁2.可中断锁3.公平锁4.读写锁java中的锁是基于对象的，比如线程A拥有了对象A的锁，线程B等待线程A释放对象A的锁对于高并发的情况下，优先使用Locksynchronized是java内置的关键字，Lock是一个接口synchr...
多线程同步机制
qianyiyiding的专栏
09-08 1780
为什么要引入同步机制在多线程环境中，可能会出现两个甚至更多的线程试图同时访问同一个资源。必须对这种潜在的资源冲突进行预防。解决方法在线程使用一个资源时为其加入锁机制。访问资源的第一个线程对其加上锁之后，其他线程便不能再使用那个资源，除非被解锁。例子比如银行取钱的例子： 首先有一个银行账户：/** * 银行账户类,里面的余额为1000 */ class Bank { private in
线程同步机制
Go_hack的博客
03-17 289
多线程编程最难的是资源的共享，因为不知道说明书及，哪个线程操作该资源，需要合理安排竞争。1. Mutex 互斥锁互斥量是一把锁，保护某个资源，若一个线程想访问某个资源，但该资源已经上锁的话，线程只能阻塞等待，直到该资源解锁，只有线程获得互斥量并加锁，才能访问该资源。1.临界资源  临界资源是一次仅允许一个进程使用的共享资源。各进程采取互斥的方式，实现共享的资源称作临界资源。属于临界资源的硬件有，打...
线程同步和加锁的机制
weixin_41157881的博客
05-11 498
#include #include #include #include<Windows.h> using namespace std; int counter = 0; std::mutex mtx; void func1() { while (true) { //Sleep(1); //std::unique_lockstd::mutex lock(mtx); if (counter...
线程的同步和锁机制（类锁）
martinyulin的专栏
04-23 782
一，什么是线程同步 线程同步
Java华丽转身 —— 多线程（二）——同步
信息技术提高班第九期
03-05 4984
多线程在同时运行的时候，执行的先后次序是无法确定的，如果这些线程同时操作某个公共的资源，最终的执行结果是不可预测的，所以要在代码中采取某些方法来保护公共资源，保证同一时刻只允许一个线程访问这些资源。   线程同步机制：                  1、多线程的同步依靠的是对象锁机制，synchronized关键字的背后就是利用了封锁来实现对共享资源的互斥访问。
多线程同步锁的使用范例
风行天下
11-14 5497
用一个买票的例子来示范多线程操作一个对象时，同步锁的使用。 如何加锁需要认真思考。
多线程的同步机制 - 死锁篇
rayen_lee的专栏
02-28 277
 使用多线程编写应用程序必然会碰到线程同步的问题.其实线程同步的机制程序员都很了解, 但在实际应用中难免会碰到一些让人头痛的问题,比如如何避免死锁等等.死锁产生的原因:下图是死锁产生的典型原因operation steps:thread1 先获得 lock1,thread2 获得lock2thread1等待lock2thread2 等待lock1一般来说, 如果
java 使用synchronized锁实现多线程同步
最新发布
03-29
在 Java 中，通过 synchronized 关键字可以实现多线程同步。synchronized 关键字可以用于方法和代码块。 1. synchronized 方法 在方法前加上 synchronized 关键字，就可以保证该方法在同一时刻只能被一个线程执行...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值