Android小知识-Java多线程相关（同步方法与同步代码块）

最新推荐文章于 2024-03-19 17:48:53 发布
最新推荐文章于 2024-03-19 17:48:53 发布
阅读量78 收藏
点赞数
文章标签： java 移动开发
原文链接：https://juejin.im/post/5beed9bbe51d451aa501f297
版权

本平台的文章更新会有延迟，大家可以关注微信公众号-顾林海，如果大家想获取最新教程，请关注微信公众号，谢谢!

“非线程安全”是指在多个线程对同一个对象中的实例变量进行并发访问，导致读取到的数据与预期不符，也就是“脏读”，而“线程安全”就是指获得的实例变量的值是经过同步处理的，不会出现“脏读”现象。

如果是方法内的私有变量就不会存在“非线程安全”问题，也就说“非线程安全”的问题存在于“实例变量”中，我们看下面这段代码：

public class Task {

    private String name = "bill";

    public void setName(int index) {
        try {
            Thread.sleep(2000);
            switch (index) {
                case 1:
                    name = "jack";
                    break;
                case 2:
                    name = "rose";
                    break;
                default:
                    name = "default";
                    break;
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("name="+name);
    }
}
复制代码

Task这个类很简单，内部只有一个setName方法，传入一个整型参数，如果是1，name就被赋值为jack，如果是2，name就被赋值为rose，最后打印name。接下来就把这个Task实例交给两个线程去处理。

public class ThreadFirst extends Thread {

    private Task mTask;

    public ThreadFirst(Task task) {
        this.mTask = task;
    }

    @Override
    public void run() {
        super.run();
        mTask.setName(1);
    }
}
复制代码
public class ThreadSecond extends Thread {

    private Task mTask;

    public ThreadSecond(Task task) {
        this.mTask = task;
    }

    @Override
    public void run() {
        super.run();
        mTask.setName(2);
    }
}
复制代码

两个线程类都差不多，唯一不同的地方就是调用mTask的setName方法分别传入1和2，如果执行这两个线程，是不是输出两个不同的name值，我们看Client代码：

public class Client {

    public static void main(String[] args) {
        Task task=new Task();
        Thread threadFirst=new ThreadFirst(task);
        Thread threadSecond=new ThreadSecond(task);
        threadFirst.start();
        threadSecond.start();
    }

}
复制代码

看看打印结果：

name=jack
name=jack
复制代码

发现输出的结果和我们预期不一样，这就是“非线程安全”问题，如何解决呢，可以按照上一节Android小知识-关于多线程的基础知识了解下中提到的给setName方法前加上关键字synchronized，代码如下：

public class Task {

    private String name = "bill";

    synchronized public void setName(int index) {
        try {
            Thread.sleep(2000);
            switch (index) {
                case 1:
                    name = "jack";
                    break;
                case 2:
                    name = "rose";
                    break;
                default:
                    name = "default";
                    break;
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("name=" + name);
    }
}
复制代码

打印结果：

name=jack
name=rose
复制代码

添加关键字synchronized后，这个setName方法就是一个同步方法，多个线程执行该方法时是排队执行的。

现在Task类中只有一个 同步方法，再添加一个非同步方法：

public class Task {

    private String name = "bill";

    synchronized public void setName(int index) {
        try {
            Thread.sleep(2000);
            switch (index) {
                case 1:
                    name = "jack";
                    break;
                case 2:
                    name = "rose";
                    break;
                default:
                    name = "default";
                    break;
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("[" + Thread.currentThread().getName() + "]" + "name=" + name);
    }

    public void getName() {
        System.out.println("[" + Thread.currentThread().getName() + "]" + "name=" + name);
    }
}
复制代码

新添加了一个getName方法，打印的时候连线程名一起打印，方便我们查看，第一个线程代码不变，两个线程类如下：

public class ThreadFirst extends Thread {

    private Task mTask;

    public ThreadFirst(Task task) {
        this.mTask = task;
    }

    @Override
    public void run() {
        super.run();
        mTask.setName(1);
    }
}
复制代码
public class ThreadSecond extends Thread {

    private Task mTask;

    public ThreadSecond(Task task) {
        this.mTask = task;
    }

    @Override
    public void run() {
        super.run();
        mTask.getName();
    }
}
复制代码

Client代码如下：

public class Client {

    public static void main(String[] args) {
        Task task=new Task();
        Thread threadFirst=new ThreadFirst(task);
        threadFirst.setName("ThreadFirst");
        Thread threadSecond=new ThreadSecond(task);
        threadSecond.setName("ThreadSecond");
        threadFirst.start();
        threadSecond.start();
    }

}
复制代码

代码没什么变化，创建一个Task实例，交由两个线程处理。

打印结果：

[ThreadSecond]name=bill
[ThreadFirst]name=jack
复制代码

按照预期应该是先执行setName方法打印jack，再执行getName方法打印jack，现在是先执行了getName方法，再执行setName方法，也就是说，ThreadFirst线程先持有了object对象的Lock锁，ThreadSecond线程可以以异步的方式调用objec对象中的非synchronized类型的方法。

现在我们给getName方法前也加上关键字synchronized：

    synchronized public void getName() {
        System.out.println("[" + Thread.currentThread().getName() + "]" + "name=" + name);
    }
复制代码

执行程序，打印：


[ThreadFirst]name=jack
[ThreadSecond]name=jack
复制代码

这样的话ThreadFirst先持有object对象的Lock锁，ThreadSecond线程如果在这时调用object对象中的synchronized类型的方法则需等待，也就是同步。

通过多个线程调用同一个方法时，为了避免数据出现交叉的情况，使用synchronized关键字来进行同步，虽然在赋值时进行了同步，但在取值时有可能出现“脏读”，发生“脏读”的情况是在读取实例变量时，此值已经被其它线程更改过了，看下面代码：

public class Task {

    private String name = "bill";
    private String password="12345";

    synchronized public void setName(String name,String password) {
        try {
            this.name=name;
            Thread.sleep(5000);
            this.password=password;
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("[" + Thread.currentThread().getName() + "]" + "name=" + name+"  password="+password);
    }

    public void getInfo(){
        System.out.println("[" + Thread.currentThread().getName() + "]" + "name=" + name+"  password="+password);
    }

}
复制代码

setName是一个同步方法，传入姓名和密码，在赋值密码前先休眠5秒，最后打印用户名和密码，而getInfo是非同步方法，用来打印用户名和密码。

public class ThreadFirst extends Thread {

    private Task mTask;

    public ThreadFirst(Task task) {
        this.mTask = task;
    }

    @Override
    public void run() {
        super.run();
        mTask.setName("jack","poiuytr");
    }
}
复制代码

ThreadFirst线程类很简单，就是调用mTask实例的setName方法，设置用户名为jack，密码为poiuytr。

public class Client {

    public static void main(String[] args) {
        Task task=new Task();
        Thread threadFirst=new ThreadFirst(task);
        threadFirst.setName("ThreadFirst");
        threadFirst.start();
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        task.getInfo();
    }

}
复制代码

创建Task实例和线程实例threadFirst，执行threadFirst线程，休眠2秒后获取相关信息。

打印：

[main]name=jack  password=12345
[ThreadFirst]name=jack  password=poiuytr
复制代码

通过打印结果就可以看出数据出现了脏读，出现脏读的原因是因为getInfo方法并不是同步的，所以可以在任意时候调用，解决办法就是加上同步synchronized关键字。

关键字synchronized拥有锁重入的功能，也就是在使用synchronized时，当一个线程得到一个对象锁后，再次请求此对象锁时是可以再次得到该对象的锁，在一个synchronized方法/块的内部调用本类的其他synchronized方法/块时，是永远可以得到锁的。当一个线程执行的代码出现异常时，其所持有的锁会自动释放。

用关键字synchronized声明方法在某些情况下是有弊端的，当某个线程调用同步方法执行一个长时间的任务，那么其他线程就必须等待比较长的时间，在这样的情况下可以使用synchronized同步语句块来解决，synchronized方法是对当前对象进行加锁，而synchronized代码块是对某一个对象进行加锁。在使用同步synchronized代码块时需要注意的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对同一个object中的所有其他synchronized(this)同步代码块的访问将被阻塞，这说明synchronized使用的“对象监视器”是一个。

多个线程调用同一个对象中的不同名称的synchronized同步方法或synchronized(this)同步代码块时，调用的效果就是按顺序执行的，也就是同步，阻塞的。为此Java提供“任意对象”作为“对象监视器”来实现同步的功能。这个任意对象大多数是实例变量及方法的参数，使用格式为synchronized(非this对象)。

weixin_33690963
关注
android-java同步方法和异步方法
安卓开发&音视频开发
02-14 9304
java同步方法和异步方法
JAVA多线程之并发与同步，Lock与Syncronized
热门推荐
csdn_aiyang的博客
03-23 2万+
说到线程，就不得不先说线程和进程的关系。进程是系统的执行单位，一般一个应用程序即是一个进程，程序启动时系统默认有一个主线程，即是UI线程，我们知道不能做耗时任务，否则ANR程序无响应。这时需要借助子线程实现，即多线程。由于线程是系统CPU的最小单位，用多线程其实就是为了更好的利用cpu的资源。一、多线程创建方式//线程休眠1000毫秒，sleep使线程进入Block状态，并释放资源xx.start();//启动线程，run函数运行@Override@Override。
Android（java）学习笔记8：同步代码块 和 同步方法 的应用
weixin_30902675的博客
05-17 136
1. 同步代码块 和 同步方法 代码示例： （1）目标类，如下： 1 package cn.himi.text; 2 3 public class SellTicket implements Runnable { 4 5 // 定义100张票 6 private static int tickets = 100; 7 8 ...
android同步代码
沐 白
08-14 412
lock,synchronized 实例 /** Lock模块事例 **/ private Lock lock; private static Integer value = 0; public void change2() { lock.lock(); try { value++; System.out.println(value); if (val...
Android（java）同步方法synchronized
weixin_34010566的博客
04-10 107
synchronized 是java语言keyword。当它用来修饰一个方法或者一个代码块的时候，可以保证在同一时刻最多仅仅有一个线程运行该段代码。synchronized keyword，它包含两种使用方法：synchronized 方法和 synchronized 块。   本文直接以代码的形式来展示 synchronized keyword的使用： 【1】sync...
android 同步执行方法吗,Android异步方法以同步方式实现
weixin_35664484的博客
05-25 666
Android强制异步转同步方法，供大家参考，具体内容如下Android系统中规定耗时任务需要在异步线程中进行，特别是网络请求必须在异步线程中进行否则会抛出NetworkOnMainThreadException,但是在一些特殊的情况我们需要保证在获得到网络请求结果之后在进行余下操作，这时候便需要在UiThread中进行相关操作。这样就需要用到线程阻塞的原理，这里可以借助Callable或Futu...
Android多线程之同步锁的使用
08-29
Android多线程之同步锁的使用 Android多线程之同步锁的使用是Android应用程序开发中非常重要的一部分。多线程编程可以提高应用程序的性能和响应速度，但是它也带来了线程安全的问题。同步锁是解决线程安全问题的...
java多线程——同步方法和同步代码块
chao2016的博客
01-30 1851
java中每个对象都有同步锁，同步方法是指进入该方法时需要获取this对象的同步锁，而同步代码块则是可以指定需要获取哪个对象的同步锁，以下代码实际上一个效果： synchronized void t(){} void t(){ synchronized(this){ } } 同步代码块可以用如下方式来使用： void t(){ synchronized(lockOb
Java_基础—多线程(同步代码块和同步方法)
SoarFly0807的博客
09-02 452
一、什么情况下需要同步？ 二、同步代码块 三、同步方法的使用
Java多线程：同步方法与同步块解析
"Java 多线程中的同步方法与同步块" Java 多线程是程序设计中的一个重要概念，它允许程序在同一时刻执行多个任务，从而提高计算机系统的效率和响应速度。多线程机制使得一个进程可以包含多个并发执行的线程，它们...
Android 同步代码块，synchronized加锁
07-13 4774
以车站售票为例，多个线程不能同时买一张票，所以把买票这个代码块加锁，等待前面线程买好了，后面线程才能进入买票 class BuyTicket implements Runnable { private int num = 10 ; //有10张票 @Override public void run() { while (num>0){ System.out
Android之多线程实现方式及并发与同步
u010227042的博客
06-24 4017
前言：说到多线程，就不得不先说它和进程的关系，这里先简单解释一下，当一个app程序启动时系统默认有一个进程和主线程，在程序运行中想要异步操作，就会创建不止一个子线程即多线程。用多线程只有一个目的，那就是更好的利用cpu的资源，因为所有的多线程代码都可以用单线程来实现。说这个话其实只有一半对，因为反应“多角色”的程序代码，最起码每个角色要给他一个线程吧，否则连实际场景都无法模拟，当然也没法说能用单线程来实现：比如最常见的“生产者，消费者模型”。 一、多线程实现方式：（三种） 1、继承Thread类，重写r
Android的代码同步repo
xcy2011sky
05-27 3282
在工作中的经常使用repo命令，但是有时会忘记一些命令和遇到的一些问题，记录下来方便已经查询。 问题1：找不到命令：repo 方法： 在下载android源码的时候用repo时提示找不到命令，可以用如下方法解决，在命令行中输入如下两行： echo 'export PATH=$PATH:$Home/bin' >>~/.bashrc export PATH=$PATH
java同步机制：synchronized
zhengyuquan的专栏
08-25 780
synchronized 是java语言关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。synchronized 关键字，它包括两种用法：synchronized 方法和 synchronized 块。   本文直接以代码的形式来展示 synchronized 关键字的使用： 【1】synchronized  Demo1：
多线程14__Java同步代码块，同步方法
daozhongyang的专栏
04-25 1756
同步代码块 参见http://www.cnblogs.com/sunzn/archive/2013/02/13/2910895.html，这里改为限制循环次数50次: new Thread() { public void run() { int i=0; while (i<50) {
JAVA-Android-多线程实现方式及并发与同步
最新发布
m0_61943758的博客
03-19 312
其实Android开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。下图是我进阶学习所积累的历年腾讯、头条、阿里、美团、字节跳动等公司2019-2021年的高频面试题，博主还把这些技术点整理成了视频和PDF（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节以上【历年大厂高级工程师面试题集】、【Android高级进阶教学视频】、【Android高级知识点学习PDF】皆无偿分享给大家。
Android 异步方法以同步方式进行
落叶Ex的博客
04-18 6555
强制异步转同步方法Android系统中规定耗时任务需要在异步线程中进行，特别是网络请求必须在异步线程中进行否则会抛出NetworkOnMainThreadException,但是在一些特殊的情况我们需要保证在获得到网络请求结果之后在进行余下操作，这时候便需要在UiThread中进行相关操作。这样就需要用到线程阻塞的原理，这里可以借助Callable或FutureTask来实现。public stat
第二章、（3）synchronized 同步代码块
Leo_Wuxg 的博客
08-02 3080
摘要： 一、synchronized 代码块中的代码是同步执行，A线程执行完才轮到B线程；不在synchronized代码块中则是异步执行。 二、synchronized(this) 和 synchronized 方法一样，锁定的是当前对象。也就是说：当多个线程同时访问 同一个 object对象的synchronized(this) 方法时，改object 对象中其他synchronized(...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值