《Java多线程编程核心技术》读后感（四）

最新推荐文章于 2024-11-11 21:19:25 发布
最新推荐文章于 2024-11-11 21:19:25 发布
阅读量101 收藏
点赞数
文章标签： java
原文链接：http://www.cnblogs.com/Michael2397/p/7842248.html
版权

 

 

 

 

将任意对象作为对象监视器

 

synchronized同步代码块还支持任意对象，使用格式为synchronized（非this对象）

package Second;

public class Service {

    private String usernameParam;
    private String passwordParam;
 　private String anyString =  new String();
    public void setUsernamePassword(String username, String password) {
        try {
            synchronized (anyString) {
                System.out.println("线程名称为：" + Thread.currentThread().getName()
                        + "在" + System.currentTimeMillis() + "进入同步块");
                usernameParam = username;
                Thread.sleep(3000);
                passwordParam = password;
                System.out.println("线程名称为：" + Thread.currentThread().getName()
                        + "在" + System.currentTimeMillis() + "离开同步块");
            }
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}
package Second;

public class ThreadA extends Thread {
    private Service service;

    public ThreadA(Service service) {
        super();
        this.service = service;
    }

    @Override
    public void run() {
        service.setUsernamePassword("a", "aa");

    }

}
package Second;

public class ThreadB extends Thread {

    private Service service;

    public ThreadB(Service service) {
        super();
        this.service = service;
    }

    @Override
    public void run() {
        service.setUsernamePassword("b", "bb");

    }

}
package Second;

public class Run {

    public static void main(String[] args) {
        Service service = new Service();

        ThreadA a = new ThreadA(service);
        a.setName("A");
        a.start();

        ThreadB b = new ThreadB(service);
        b.setName("B");
        b.start();

    }

}

package Second;

public class Service {

    private String usernameParam;
    private String passwordParam;
    public void setUsernamePassword(String username, String password) {
        try {
            String anyString = new String();
            synchronized (anyString) {
                System.out.println("线程名称为：" + Thread.currentThread().getName()
                        + "在" + System.currentTimeMillis() + "进入同步块");
                usernameParam = username;
                Thread.sleep(3000);
                passwordParam = password;
                System.out.println("线程名称为：" + Thread.currentThread().getName()
                        + "在" + System.currentTimeMillis() + "离开同步块");
            }
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}

 

package Second;

public class Service {

    private String anyString = new String();

    public void a() {
        try {
            synchronized (anyString) {
                System.out.println("a begin");
                Thread.sleep(3000);
                System.out.println("a   end");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    synchronized public void b() {
        System.out.println("b begin");
        System.out.println("b   end");
    }

}
package Second;

public class ThreadA extends Thread {
    private Service service;

    public ThreadA(Service service) {
        super();
        this.service = service;
    }

    @Override
    public void run() {
        service.a();

    }

}
package Second;

public class ThreadB extends Thread {

    private Service service;

    public ThreadB(Service service) {
        super();
        this.service = service;
    }

    @Override
    public void run() {
        service.b();

    }

}
package Second;

public class Run {

    public static void main(String[] args) {
        Service service = new Service();

        ThreadA a = new ThreadA(service);
        a.setName("A");
        a.start();

        ThreadB b = new ThreadB(service);
        b.setName("B");
        b.start();

    }

}

由于对象监视器不同，所以运行结果就是异步的

下面验证多个线程调用同一个方法是随机的

package Second;

import java.util.ArrayList;
import java.util.List;

public class MyList {

    private List list = new ArrayList();

    synchronized public void add(String username) {
        System.out.println("ThreadName=" + Thread.currentThread().getName()
                + "执行了add方法！");
        list.add(username);
        System.out.println("ThreadName=" + Thread.currentThread().getName()
                + "退出了add方法！");
    }

    synchronized public int getSize() {
        System.out.println("ThreadName=" + Thread.currentThread().getName()
                + "执行了getSize方法！");
        int sizeValue = list.size();
        System.out.println("ThreadName=" + Thread.currentThread().getName()
                + "退出了getSize方法！");
        return sizeValue;
    }

}
package Second;

public class MyThreadA extends Thread {

    private MyList list;

    public MyThreadA(MyList list) {
        super();
        this.list = list;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100000; i++) {
            list.add("threadA" + (i + 1));
        }
    }

}
package Second;

public class MyThreadB extends Thread {

    private MyList list;

    public MyThreadB(MyList list) {
        super();
        this.list = list;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100000; i++) {
            list.add("threadB" + (i + 1));
        }
    }
}
package Second;

public class Test {

    public static void main(String[] args) {
        MyList mylist = new MyList();

        MyThreadA a = new MyThreadA(mylist);
        a.setName("A");
        a.start();

        MyThreadB b = new MyThreadB(mylist);
        b.setName("B");
        b.start();
    }

}

下面展示多线程出现脏读的情况

package Second;

import java.util.ArrayList;
import java.util.List;

public class MyOneList {

    private List list = new ArrayList();

    synchronized public void add(String data) {
        list.add(data);
    };

    synchronized public int getSize() {
        return list.size();
    };

}
package Second;

public class MyService {

    public MyOneList addServiceMethod(MyOneList list, String data) {
        try {
            synchronized (list) {
                if (list.getSize() < 1) {
                    Thread.sleep(2000);
                    list.add(data);
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return list;
    }

}
package Second;

public class MyThread1 extends Thread {

    private MyOneList list;

    public MyThread1(MyOneList list) {
        super();
        this.list = list;
    }

    @Override
    public void run() {
        MyService msRef = new MyService();
        msRef.addServiceMethod(list, "A");
    }

}
package Second;

public class MyThread2 extends Thread {

    private MyOneList list;

    public MyThread2(MyOneList list) {
        super();
        this.list = list;
    }

    @Override
    public void run() {
        MyService msRef = new MyService();
        msRef.addServiceMethod(list, "B");
    }

}
package Second;

public class Run {

    public static void main(String[] args) throws InterruptedException {
        MyOneList list = new MyOneList();

        MyThread1 thread1 = new MyThread1(list);
        thread1.setName("A");
        thread1.start();

        MyThread2 thread2 = new MyThread2(list);
        thread2.setName("B");
        thread2.start();
        
        Thread.sleep(6000);
        
        System.out.println("listSize=" + list.getSize());

    }

}

"脏读"出现了。出现的原因是两个线程以异步的方式返回list参数的size()大小。解决办法是“”同步化

package Second;

public class MyService {

    public MyOneList addServiceMethod(MyOneList list, String data) {
        try {
            synchronized (list) {
                if (list.getSize() < 1) {
                    Thread.sleep(2000);
                    list.add(data);
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return list;
    }

}

由于list参数对象在项目中是一份实例，是单例的，而且也正需要对list参数的getsize()方法做同步的调用，所以就对list参数进行同步处理

 

转载于:https://www.cnblogs.com/Michael2397/p/7842248.html

weixin_30410999
关注
Java多线程编程核心技术.zip
09-24
本资料"Java多线程编程核心技术.zip"深入探讨了这些核心技术，并提供了源码供学习者实践和理解。 1. **线程的创建与启动** - 继承Thread类：自定义类继承Thread类，重写run()方法，然后创建该类对象并调用start()...
《Java多线程编程核心技术》读后感（十五）
哎呀妈呀脑壳疼脑壳疼
11-19 167
《Java多线程编程核心技术》读后感（十五）     线程的状态 线程对象在不同的运行时期有不同的状态，状态信息就存在与State枚举类中。 验证New,Runnable，Terminated new:线程实例化后还从未执行start()方法时的状态 runnable：线程进入运行的状态 terminated：线程被销毁时的状态 pa...
《Java多线程编程核心技术》读后总结
幺鹿
04-14 781
线程线程，有时被称为轻量级进程(Lightweight Process，LWP），是程序执行流的最小单元，更多信息参见百度百度-线程。与创建线程相关的两个类：Thread、Runnable。public class Thread implements Runnable{ private Runnable target; @Override public void run()
think in java第十四章关于多线程的读书笔记
dksokil的专栏
09-23 845
      书的这一章主要讨论的是多线程的使用以及关于多线程中访问共享数据中遇到的问题。首先总结一下多线程的使用方法。方法有2种，第一种是直接继承 Thread类，然后在public void run()写入需要用在线程的代码。作完以后只需要调用start()方法，就会开始新开一个线程并执行run()中的代码了。另外一种方法是使用 runnable接口，同样需要使用线程的代码写入run()方法中，
读书笔记——Java多线程编程核心技术
lianup的博客
09-09 1358
第一章 Java多线程技能      1.1进程/线程/多线程      进程：受操作系统管理的基本运行单位，即操作系统中正在运行的exe程序。      线程：在进程中独立运行的子任务。      1.2      实现多线程方法：1.继承Thread 2.实现Runnable接口      1.继承Thread      Thread.start()：通知”线程规划器“此线程已经...
Java多线程编程 深入详解
热门推荐
走在命运的左岸
01-17 1万+
《Java多线程编程 深入详解》读书笔记 第一章 多进程多线程概述 线程概述 进程（PROCESS）：CPU的执行路径 多进程：系统中同时运行多个程序 线程（THREAD）：运行在进程当中的运行单元 多线程：每个进程里面有多个独立的或者相互有协作关系的运行单元 第二章 多线程详解 线程创建 继承 Thread 类 其中 Thread 实现 Runnable ；符
Java多线程编程核心技术_完整版_java_
09-30
本教程《Java多线程编程核心技术》将深入探讨这一主题。 一、线程的创建与启动 1. 继承Thread类：创建一个新的类，该类继承自Thread类，然后重写run()方法，最后创建该类的实例并调用start()方法启动线程。 2. 实现...
JAVA多线程编程技术PDF
08-28
这份“JAVA多线程编程技术PDF”是学习和掌握这一领域的经典资料，涵盖了多线程的全部知识点。 首先，多线程的核心概念包括线程的创建与启动。在Java中，可以通过实现Runnable接口或继承Thread类来创建线程。创建后...
java多线程并发编程 核心技术应用实践
06-21
在《java多线程并发编程核心技术应用实践》中，我们将深入探讨Java平台上的并发机制、线程安全与同步控制、线程池以及实战技巧。 首先，我们需要理解Java中的线程基础。线程是程序执行的最小单位，一个进程可以有多...
【JAVA多线程】多线程编程核心技术学习资料
03-02
这份"Java多线程编程核心技术学习资料"正是针对这一主题提供的一份宝贵的学习资源，适合初、中级Java开发人员提升自己的多线程编程技能。 在Java中，多线程主要通过以下方式实现： 1. 继承Thread类：创建一个新的...
《Java多线程编程核心技术》读后感（十）
哎呀妈呀脑壳疼脑壳疼
11-18 139
《Java多线程编程核心技术》读后感（十） 一生产一消费：操作栈 本实例是使生产者向堆栈List对象中放入数据，使消费者从List堆栈中取出数据。List最大容量是1 package Third; import java.util.ArrayList; import java.util.List; public class MyStac...
关于学习java多线程的一些感想
zhoulupeng2012的博客
11-29 638
一、基本概念 1.进程与线程 进程作为程序的一次执行，它是有独立的内存空间的；而线程可以理解为一个进程中的多个独立运行的子任务，是CPU调度的最小单元。一个进程可以包含多个线程。2.实现线程的两种方式 （1）继承Thread类 （2）实现Runnable接口（推荐， 因为可以支持多继承） 注意：线程是一个子任务，CPU以随机的时间来调用他的run方法，若同时启动多个线程，调用start（）
Java多线程编程实战指南（核心篇）读书笔记（五）
冷血之心的博客
08-05 2768
Java多线程编程实战指南（核心篇）读书笔记（五）
java多线程核心技术_《Java多线程编程核心技术》读后感（一）
weixin_31147757的博客
02-16 165
1、继承ThreadpackageFirst;public class MyThread extendsThread {public voidrun() {super.run();System.out.println("mythread");}}packageFirst;public classTest {public static voidmain(String[] args) {MyThrea...
日常bug记录，easyexcel导入报错convert data ... to class java.math.BigDecimal error
mm
11-11 115
排查发现实体类中有BigDecimal属性，然而数据中这个属性为null，进行转换时报错。在实体类上加上自定义转换器。解决方法：自定义转换器类。
SpringBoot 实现图片加水印
最新发布
心猿意码
11-11 281
通过上述步骤，我们可以在SpringBoot项目中实现一个简单的图片加水印功能。当然，实际应用中可能需要更复杂的水印处理，比如水印图片、调整水印位置等，可以根据需求进行相应的扩展和优化。
刷题---顺序表算法题
weixin_63997543的博客
11-11 274
顺序算法题----力扣刷题
JAVA-01-变量
LJH_laura_li的博客
11-08 468
在方法、构造函数或块内部定义的变量。
Java多线程编程核心技术详解与实战
"《Java多线程编程核心技术》是一本由高洪岩撰写的专著，作为'Java核心技术系列'的一部分，它深入探讨了Java多线程编程的关键技术和实践。本书旨在弥补市场上同类教材的不足，即缺乏对Java多线程技术的全面覆盖。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值