java多线程基本概述（三）—

1.1、synchronized方法的弊端

package commonutils;

public class CommonUtils {

    public static long beginTime1;

    public static long endTime1;

    public static long beginTime2;

    public static long endTime2;

}

=============================

package mytask;

import commonutils.CommonUtils;

public class Task {

    private String getData1;

    private String getData2;

    public synchronized void doLongTimeTask() {

        try {

            System.out.println("begin task");

            Thread.sleep(3000);

            getData1 = "长时间处理任务后从远程返回的值1 threadName="

                    + Thread.currentThread().getName();

            getData2 = "长时间处理任务后从远程返回的值2 threadName="

                    + Thread.currentThread().getName();

            System.out.println(getData1);

            System.out.println(getData2);

            System.out.println("end task");

        } catch (InterruptedException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

    }

}

=======================================

package mythread;

import commonutils.CommonUtils;

import mytask.Task;

public class MyThread1 extends Thread {

    private Task task;

    public MyThread1(Task task) {

        super();

        this.task = task;

    }

    @Override

    public void run() {

        super.run();

        CommonUtils.beginTime1 = System.currentTimeMillis();

        task.doLongTimeTask();

        CommonUtils.endTime1 = System.currentTimeMillis();

    }

}

=============================================

package mythread;

import commonutils.CommonUtils;

import mytask.Task;

public class MyThread2 extends Thread {

    private Task task;

    public MyThread2(Task task) {

        super();

        this.task = task;

    }

    @Override

    public void run() {

        super.run();

        CommonUtils.beginTime2 = System.currentTimeMillis();

        task.doLongTimeTask();

        CommonUtils.endTime2 = System.currentTimeMillis();

    }

}

package test;

import mytask.Task;

import mythread.MyThread1;

import mythread.MyThread2;

import commonutils.CommonUtils;

public class Run {

    public static void main(String[] args) {

        Task task = new Task();

        MyThread1 thread1 = new MyThread1(task);

        thread1.start();

        MyThread2 thread2 = new MyThread2(task);

        thread2.start();

        try {

            Thread.sleep(10000);

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

        long beginTime = CommonUtils.beginTime1;

        if (CommonUtils.beginTime2 < CommonUtils.beginTime1) {

            beginTime = CommonUtils.beginTime2;

        }

        long endTime = CommonUtils.endTime1;

        if (CommonUtils.endTime2 > CommonUtils.endTime1) {

            endTime = CommonUtils.endTime2;

        }

        System.out.println("耗时：" + ((endTime - beginTime) / 1000));

    }

}

输出结果：

begin task

长时间处理任务后从远程返回的值1 threadName=Thread-0

长时间处理任务后从远程返回的值2 threadName=Thread-0

end task

begin task

长时间处理任务后从远程返回的值1 threadName=Thread-1

长时间处理任务后从远程返回的值2 threadName=Thread-1

end task

耗时：6

当把同步方法改为同步代码块时，

package mytask;

import commonutils.CommonUtils;

public class Task {

    private String getData1;

    private String getData2;

    public  void doLongTimeTask() {

        synchronized(Task.class){

            try {

                System.out.println("begin task");

                Thread.sleep(3000);

                getData1 = "长时间处理任务后从远程返回的值1 threadName="

                        + Thread.currentThread().getName();

                getData2 = "长时间处理任务后从远程返回的值2 threadName="

                        + Thread.currentThread().getName();

                System.out.println(getData1);

                System.out.println(getData2);

                System.out.println("end task");

            } catch (InterruptedException e) {

                // TODO Auto-generated catch block

                e.printStackTrace();

            }

        }

    }

}

输出结果：

begin task

长时间处理任务后从远程返回的值1 threadName=Thread-0

长时间处理任务后从远程返回的值2 threadName=Thread-0

end task

begin task

长时间处理任务后从远程返回的值1 threadName=Thread-1

长时间处理任务后从远程返回的值2 threadName=Thread-1

end task

耗时：6

可见，并没有提升效率，这是因为锁定的范围比较广，所以效果和锁方法的差别并不是太。那么可以缩小边界区，也就是资源真正开始竞争的地方。因为类中的成员变量才是资源的竞争对象，所以需要在访问这些变量的地方进行锁定。那么代码改为如下：

package mytask;

import commonutils.CommonUtils;

public class Task {

    private String getData1;

    private String getData2;

    public  void doLongTimeTask() {

            try {

                System.out.println("begin task");

                Thread.sleep(3000);

                getData1 = "长时间处理任务后从远程返回的值1 threadName="

                        + Thread.currentThread().getName();

                getData2 = "长时间处理任务后从远程返回的值2 threadName="

                        + Thread.currentThread().getName();

                synchronized(Task.class){

                    System.out.println(getData1);

                    System.out.println(getData2);

                }

                System.out.println("end task");

            } catch (InterruptedException e) {

                // TODO Auto-generated catch block

                e.printStackTrace();

            }

    }

}

输出结果：

begin task

begin task

长时间处理任务后从远程返回的值1 threadName=Thread-0

长时间处理任务后从远程返回的值2 threadName=Thread-0

end task

长时间处理任务后从远程返回的值1 threadName=Thread-1

长时间处理任务后从远程返回的值2 threadName=Thread-1

end task

耗时：3

这时候可以看到时间已经减小了，这就出现一部分同步，一部分异步了。如何验证是真的一半同步一半异步呢？

package mytask;

public class Task {

    public void doLongTimeTask() {

        for (int i = 0; i < 100; i++) {

            System.out.println("nosynchronized threadName="

                    + Thread.currentThread().getName() + " i=" + (i + 1));

        }

        System.out.println("");

        synchronized (this) {

            for (int i = 0; i < 100; i++) {

                System.out.println("synchronized threadName="

                        + Thread.currentThread().getName() + " i=" + (i + 1));

            }

        }

    }

}

输出结果：

=================================非同步块异步执行

nosynchronized threadName=Thread-0 i=1

nosynchronized threadName=Thread-1 i=1

nosynchronized threadName=Thread-0 i=2

nosynchronized threadName=Thread-1 i=2

nosynchronized threadName=Thread-0 i=3

nosynchronized threadName=Thread-1 i=3

nosynchronized threadName=Thread-0 i=4

nosynchronized threadName=Thread-1 i=4

nosynchronized threadName=Thread-0 i=5

nosynchronized threadName=Thread-1 i=5

nosynchronized threadName=Thread-0 i=6

nosynchronized threadName=Thread-1 i=6

nosynchronized threadName=Thread-0 i=7

nosynchronized threadName=Thread-1 i=7

nosynchronized threadName=Thread-0 i=8

nosynchronized threadName=Thread-1 i=8

=================================同步块同步执行

synchronized threadName=Thread-1 i=85

synchronized threadName=Thread-1 i=86

synchronized threadName=Thread-1 i=87

synchronized threadName=Thread-1 i=88

synchronized threadName=Thread-1 i=89

synchronized threadName=Thread-1 i=90

synchronized threadName=Thread-1 i=91

synchronized threadName=Thread-1 i=92

synchronized threadName=Thread-1 i=93

synchronized threadName=Thread-1 i=94

synchronized threadName=Thread-1 i=95

synchronized threadName=Thread-1 i=96

synchronized threadName=Thread-1 i=97

synchronized threadName=Thread-1 i=98

synchronized threadName=Thread-1 i=99

synchronized threadName=Thread-1 i=100

synchronized threadName=Thread-0 i=1

synchronized threadName=Thread-0 i=2

synchronized threadName=Thread-0 i=3

synchronized threadName=Thread-0 i=4

synchronized threadName=Thread-0 i=5

synchronized threadName=Thread-0 i=6

synchronized threadName=Thread-0 i=7

synchronized threadName=Thread-0 i=8

synchronized threadName=Thread-0 i=9

synchronized threadName=Thread-0 i=10

synchronized threadName=Thread-0 i=11

synchronized threadName=Thread-0 i=12

synchronized threadName=Thread-0 i=13

synchronized threadName=Thread-0 i=14

synchronized threadName=Thread-0 i=15

synchronized threadName=Thread-0 i=16

java多线程基本概述（三）——同步块的更多相关文章

java多线程中的三种特性
java多线程中的三种特性原子性(Atomicity) 原子性是指在一个操作中就是cpu不可以在中途暂停然后再调度,既不被中断操作,要不执行完成,要不就不执行. 如果一个操作时原子性的,那么多线程并 ...
Java多线程学习（三）volatile关键字
转载请备注地址:https://blog.csdn.net/qq_34337272/article/details/79680693 系列文章传送门: Java多线程学习(一)Java多线程入门 Ja ...
Java多线程——线程之间的同步
Java多线程——线程之间的同步摘要:本文主要学习多线程之间是如何同步的,如何使用volatile关键字,如何使用synchronized修饰的同步代码块和同步方法解决线程安全问题. 部分内容来自以 ...
Java多线程之线程的同步
Java多线程之线程的同步实际开发中我们也经常提到说线程安全问题,那么什么是线程安全问题呢? 线程不安全就是说在多线程编程中出现了错误情况,由于系统的线程调度具有一定的随机性,当使用多个线程来访问同 ...
如何实现有返回值的多线程 JAVA多线程实现的三种方式
可返回值的任务必须实现Callable接口,类似的,无返回值的任务必须Runnable接口.执行Callable任务后,可以获取一个Future的对象,在该对象上调用get就可以获取到Callable ...
Java 多线程基础（三） start() 和 run()
Java 多线程基础(三) start() 和 run() 通过之前的学习可以看到,创建多线程过程中,最常用的便是 Thread 类中的 start() 方法和线程类的 run() 方法.两个方法都包 ...
java多线程二之线程同步的三种方法
java多线程的难点是在:处理多个线程同步与并发运行时线程间的通信问题.java在处理线程同步时,常用方法有: 1.synchronized关键字. 2.Lock显示加锁. 3.信号量Se ...
java 多线程: Thread 并发访问-代码块同步synchronized {}；String作为被锁的对象
方法同步的弊端方法同步的时候,如果一个方法需要线程安全控制的代码速度其实很快,但是还有其他的业务逻辑代码耗时非常长(比如网络请求),这样所有的线程就在这一块就等待着了,这样造成了极大的资源浪费如果并 ...
java多线程基本概述（三）——同步方法
非线程安全其实是在多个线程对同一个对象实例的变量进行并发访问的时候发生,产生的后果就是脏读,也就是取到的数据是修改过的.而线程安全就是获得的实例变量的值是经过同步处理的,从而不会出现脏读现象. 1.1 ...

随机推荐

Android SDK教程
Android SDK 网络问题解析 Android 客户端网络不稳定,会导致App 有时候无法及时收到 Push 消息. 很多开发者认为这是因为 JPush 推送不稳定.延迟,甚至有时候认为 JPu ...
for循环的表达规则，for循环的嵌套，跳转语句；穷举；迭代；异常处理
for循环的基本格式 for(表达式1:表达式2:表达式3) { 循环体: } for循环的四要素表达式1就是变量初始化:表达式2就是循环条件:表达式3是状态改变 static void Main( ...
jQuery（20161108）
jQuery的引入包必须要在其他引入包的最上方,否则会出错.因为如果在页面加载完成后还未执行jQuery包,那么jQuery的引入包就没用了如果浏览器报错:Uncaught Error: Boots ...
利用Socket与硬件通信（智能家居）
前几天做一个智能家居APP,硬件段使用的是ESP8266WIFI模块,其实不管是WIFI模块还是蓝牙,通信都是同样一个道理,获取IP和端口来进行通信. 我是通过XCOM v2.0 发送信息,移动端接收 ...
清理浏览器网站缓存的几种方法（meta,form表单，ajax）
1.meta方法 HTML header中加入 <meta http-equiv="pragma" content="no-cache"> 说明 ...
Apache Flume日志收集系统简介
Apache Flume是一个分布式.可靠.可用的系统,用于从大量不同的源有效地收集.聚合.移动大量日志数据进行集中式数据存储. Flume简介 Flume的核心是Agent,Agent中包含Sour ...
iOS 集成Weex入门教程
前言自Weex发布伊始, 其口号 "Write Once, Run Everywhere"就吸引了大批前端与客户端程序猿纷纷入坑, 我也不能独善其中. 就我目前所学习Weex的经 ...
Python中闭包、装饰器的概念
1.闭包(Closure)的概念: 内部函数中对enclosing作用域的变量进行引用 1 passline = 60 2 def func(val): 3 print('%x' % id(val)) ...
Asp.NetCore1.1版本没了project.json，这样来生成跨平台包
本章将要和大家分享的是Asp.NetCore1.1版本去掉了project.json后如何打包生成跨平台包, 为了更好跟进AspNetCore的发展,把之前用来做netcore开发的vs2015卸载后 ...
HBuilder的webview操作
HBuilder的webview操作 webviewAPI文档:http://www.html5plus.org/doc/zh_cn/webview.html 创建新的webview窗口: Webvi ...

java多线程基本概述（三）——同步块

java多线程基本概述（三）——同步块的更多相关文章

随机推荐

热门专题