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

最新推荐文章于 2021-11-19 22:26:37 发布
最新推荐文章于 2021-11-19 22:26:37 发布
阅读量127 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013983628/article/details/86148741
版权

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

 

 

 

 

方法内的变量为线程安全

package Second;

public class HasSelfPrivateNum {
    public void addI(String username) {
        try {
            int num = 0;
            if (username.equals("a")) {
                num = 100;
                System.out.println("a set over!");
                Thread.sleep(2000);
            } else {
                num = 200;
                System.out.println("b set over!");
            }
            System.out.println(username + " num=" + num);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}
package Second;

public class ThreadA extends Thread {

    private HasSelfPrivateNum numRef;

    public ThreadA(HasSelfPrivateNum numRef) {
        super();
        this.numRef = numRef;
    }

    @Override
    public void run() {
        super.run();
        numRef.addI("a");
    }


}
package Second;

public class ThreadB extends Thread {

    private HasSelfPrivateNum numRef;

    public ThreadB(HasSelfPrivateNum numRef) {
        super();
        this.numRef = numRef;
    }

    @Override
    public void run() {
        super.run();
        numRef.addI("b");
    }

}
package Second;

public class Run {
    public static void main(String[] args) {

        HasSelfPrivateNum numRef = new HasSelfPrivateNum();

        ThreadA athread = new ThreadA(numRef);
        athread.start();

        ThreadB bthread = new ThreadB(numRef);
        bthread.start();

    }
}

 

实例变量非线程安全

如果对象中有多个实例变量，则运行结果有可能出现交叉的情况

如果对象仅有一个变量，则有可能出现覆盖的情况

package Second;

public class HasSelfPrivateNum {
    private int num = 0;
    public void addI(String username) {
        try {
            if (username.equals("a")) {
                num = 100;
                System.out.println("a set over!");
                Thread.sleep(2000);
            } else {
                num = 200;
                System.out.println("b set over!");
            }
            System.out.println(username + " num=" + num);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

解决方案：

package Second;

public class HasSelfPrivateNum {
    private int num = 0;
    synchronized public void addI(String username) {
        try {
            if (username.equals("a")) {
                num = 100;
                System.out.println("a set over!");
                Thread.sleep(2000);
            } else {
                num = 200;
                System.out.println("b set over!");
            }
            System.out.println(username + " num=" + num);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

实验结论：在两个线程访问同一个对象重点额同步方法时一定是线程安全的

多个对象多个锁

其他代码实现代码如上

package Second;

public class Run {
    public static void main(String[] args) {


        HasSelfPrivateNum numRef1 = new HasSelfPrivateNum();
        HasSelfPrivateNum numRef2 = new HasSelfPrivateNum();

        ThreadA athread = new ThreadA(numRef1);
        athread.start();

        ThreadB bthread = new ThreadB(numRef2);
        bthread.start();

    }
}

 

 上面例子是两个线程分别访问同一个类的两个不同实例的相同名称的同步方法，效果却以异步的方式运行的。本实例由于创建了两个业务对象，在系统中产生出两个锁，所以运行结果是异步的

 

 sychronized方法与锁对象

证明前面讲述的线程锁的是对象

package Second;

public class MyObject {

     public void methodA() {
        try {
            System.out.println("begin methodA threadName="
                    + Thread.currentThread().getName());
            Thread.sleep(500000);
            System.out.println("end");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
package Second;

public class ThreadA extends Thread {

    private MyObject object;

    public ThreadA(MyObject object) {
        super();
        this.object = object;
    }

    @Override
    public void run() {
        super.run();
        object.methodA();
    }

}
package Second;

public class ThreadB extends Thread {

    private MyObject object;

    public ThreadB(MyObject object) {
        super();
        this.object = object;
    }

    @Override
    public void run() {
        super.run();
        object.methodA();
    }

}
package Second;

public class Run {

    public static void main(String[] args) {
        MyObject object = new MyObject();
        ThreadA a = new ThreadA(object);
        a.setName("A");
        ThreadB b = new ThreadB(object);
        b.setName("B");

        a.start();
        b.start();
    }
}

 

 

package Second;

public class MyObject {

    synchronized public void methodA() {
        try {
            System.out.println("begin methodA threadName="
                    + Thread.currentThread().getName());
            Thread.sleep(5000);
            System.out.println("end");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

调用关键字synchronized声明的方法一定是在排队运行中，另外需要牢牢记住“共享”两个字，只有共享资源的读写访问才需要同步化，如果不是共享资源，就没有同步的必要

 

package chapter02.section01.thread_2_1_4.project_2_synchronizedMethodLockObject2;

public class MyObject {

    synchronized public void methodA() {
        try {
            System.out.println("begin methodA threadName="
                    + Thread.currentThread().getName());
            Thread.sleep(5000);
            System.out.println("end endTime=" + System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

  public void methodB() {
        try {
            System.out.println("begin methodB threadName="
                    + Thread.currentThread().getName() + " begin time="
                    + System.currentTimeMillis());
            Thread.sleep(5000);
            System.out.println("end");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}
package chapter02.section01.thread_2_1_4.project_2_synchronizedMethodLockObject2;

public class ThreadA extends Thread {

    private MyObject object;

    public ThreadA(MyObject object) {
        super();
        this.object = object;
    }

    @Override
    public void run() {
        super.run();
        object.methodA();
    }

}
package chapter02.section01.thread_2_1_4.project_2_synchronizedMethodLockObject2;

public class ThreadB extends Thread {

    private MyObject object;

    public ThreadB(MyObject object) {
        super();
        this.object = object;
    }

    @Override
    public void run() {
        super.run();
        object.methodB();
    }
}
package chapter02.section01.thread_2_1_4.project_2_synchronizedMethodLockObject2;

public class Run {

    public static void main(String[] args) {
        MyObject object = new MyObject();
        ThreadA a = new ThreadA(object);
        a.setName("A");
        ThreadB b = new ThreadB(object);
        b.setName("B");

        a.start();
        b.start();
    }

}

虽然线程A先持有了object对象的锁，但线程B完全可以异步调用非synchronized类型的方法

package chapter02.section01.thread_2_1_4.project_2_synchronizedMethodLockObject2;

public class MyObject {

    synchronized public void methodA() {
        try {
            System.out.println("begin methodA threadName="
                    + Thread.currentThread().getName());
            Thread.sleep(5000);
            System.out.println("end endTime=" + System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    synchronized public void methodB() {
        try {
            System.out.println("begin methodB threadName="
                    + Thread.currentThread().getName() + " begin time="
                    + System.currentTimeMillis());
            Thread.sleep(5000);
            System.out.println("end");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

脏读

发生脏读的情况是在读取实例变量时，此值已经被其他线程更改过了

package Second;

public class PublicVar {

    public String username = "A";
    public String password = "AA";

    synchronized public void setValue(String username, String password) {
        try {
            this.username = username;
            Thread.sleep(5000);
            this.password = password;

            System.out.println("setValue method thread name=" + Thread.currentThread().getName() + " username="
                    + username + " password=" + password);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void getValue() {
        System.out.println("getValue method thread name=" + Thread.currentThread().getName() + " username=" + username
                + " password=" + password);
    }
}
package Second;

public class ThreadA extends Thread {

    private PublicVar publicVar;

    public ThreadA(PublicVar publicVar) {
        super();
        this.publicVar = publicVar;
    }

    @Override
    public void run() {
        super.run();
        publicVar.setValue("B", "BB");
    }

}
package Second;

public class Test {

    public static void main(String[] args) {
        try {
            PublicVar publicVarRef = new PublicVar();
            ThreadA thread = new ThreadA(publicVarRef);
            thread.start();

            Thread.sleep(200);

            publicVarRef.getValue();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
}

出现脏读是因为getValue()并不是同步的，所以可以在任意时候进行调用

package Second;



public class PublicVar {

    public String username = "A";
    public String password = "AA";

    synchronized public void setValue(String username, String password) {
        try {
            this.username = username;
            Thread.sleep(5000);
            this.password = password;

            System.out.println("setValue method thread name=" + Thread.currentThread().getName() + " username="
                    + username + " password=" + password);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    synchronized public void getValue() {
        System.out.println("getValue method thread name=" + Thread.currentThread().getName() + " username=" + username
                + " password=" + password);
    }
}

synchronized锁重入

也就是在使用synchronized时，当一个线程得到一个对象锁后，再次请求此对象锁时是可以再次得到该对象的锁的。这也证明在一个synchronized方法/块内的内部调用本类的其他synchronized方法/块时，是用户可以得到锁的。

package Second;

public class Service {

    synchronized public void service1() {
        System.out.println("service1");
        service2();
    }

    synchronized public void service2() {
        System.out.println("service2");
        service3();
    }

    synchronized public void service3() {
        System.out.println("service3");
    }

}

 

package Second;

public class MyThread extends Thread {
    @Override
    public void run() {
        Service service = new Service();
        service.service1();
    }

}
package Second;

public class Run {
    public static void main(String[] args) {
        MyThread t = new MyThread();
        t.start();
    }
}

 

package Second;

public class Main {

    public int i = 10;

    synchronized public void operateIMainMethod() {
        try {
            i--;
            System.out.println("main print i=" + i);
            Thread.sleep(100);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}
package Second;

public class Sub extends Main {

    synchronized public void operateISubMethod() {
        try {
            while (i > 0) {
                i--;
                System.out.println("sub print i=" + i);
                Thread.sleep(100);
                this.operateIMainMethod();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}
package Second;

public class MyThread extends Thread {
    @Override
    public void run() {
        Sub sub = new Sub();
        sub.operateISubMethod();
    }

}
package Second;


public class Run {
    public static void main(String[] args) {
        MyThread t = new MyThread();
        t.start();
        Main main = new Main();
        System.out.println(main.i);
    }
}

此实验表明，当存在父子类继承关系时，子类是完全可以通过“”可重入锁“”调用父类的同步方法的

出现异常，锁自动释放

当一个线程执行的代码出现异常时，其所持有的锁会自动释放

package Second;

public class Service {
    synchronized public void testMethod() {
        if (Thread.currentThread().getName().equals("a")) {
            System.out.println("ThreadName=" + Thread.currentThread().getName()
                    + " run beginTime=" + System.currentTimeMillis());
            int i = 1;
            while (i == 1) {
                if (("" + Math.random()).substring(0, 8).equals("0.123456")) {
                    System.out.println("ThreadName="
                            + Thread.currentThread().getName()
                            + " run   exceptionTime="
                            + System.currentTimeMillis());
                    Integer.parseInt("a");
                }
            }
        } else {
            System.out.println("Thread B run Time="
                    + System.currentTimeMillis());
        }
    }
}
package Second;

public class ThreadA extends Thread {

    private Service service;

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

    @Override
    public void run() {
        service.testMethod();
    }

}
package Second    ;

public class ThreadB extends Thread {
    private Service service;

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

    @Override
    public void run() {
        service.testMethod();
    }

}
package Second;

public class Test {

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

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

            Thread.sleep(500);

            ThreadB b = new ThreadB(service);
            b.setName("b");
            b.start();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

线程a出现异常并释放锁，线程b进入方法正常打印

同步不具有继承性

package Second;

public class Main {

    synchronized public void serviceMethod() {
        try {
            System.out.println("int main 下一步 sleep begin threadName="
                    + Thread.currentThread().getName() + " time="
                    + System.currentTimeMillis());
            Thread.sleep(5000);
            System.out.println("int main 下一步 sleep   end threadName="
                    + Thread.currentThread().getName() + " time="
                    + System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}
package Second;

public class Sub extends Main {

    @Override
    synchronized public void serviceMethod() {
        try {
            System.out.println("int sub 下一步 sleep begin threadName="
                    + Thread.currentThread().getName() + " time="
                    + System.currentTimeMillis());
            Thread.sleep(5000);
            System.out.println("int sub 下一步 sleep   end threadName="
                    + Thread.currentThread().getName() + " time="
                    + System.currentTimeMillis());
            super.serviceMethod();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}
package Second;

public class MyThreadA extends Thread {

    private Sub sub;

    public MyThreadA(Sub sub) {
        super();
        this.sub = sub;
    }

    @Override
    public void run() {
        sub.serviceMethod();
    }

}
package Second;

public class MyThreadB extends Thread {

    private Sub sub;

    public MyThreadB(Sub sub) {
        super();
        this.sub = sub;
    }

    @Override
    public void run() {
        sub.serviceMethod();
    }
}

所以还要在子类的方法中添加synchronized关键字

 

posted on 2017-11-15 17:07 Michael2397 阅读(...) 评论(...) 编辑 收藏

哎呀妈呀脑壳疼脑壳疼
关注
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...
《Java多线程编程核心技术》读后感（一）
哎呀妈呀脑壳疼脑壳疼
11-14 330
《Java多线程编程核心技术》读后感（一）             1、继承Thread package First; public class MyThread extends Thread { public void run() { super.run(); System.out....
《Java多线程编程核心技术》读后感（十）
哎呀妈呀脑壳疼脑壳疼
11-18 139
《Java多线程编程核心技术》读后感（十） 一生产一消费：操作栈 本实例是使生产者向堆栈List对象中放入数据，使消费者从List堆栈中取出数据。List最大容量是1 package Third; import java.util.ArrayList; import java.util.List; public class MyStac...
《Java多线程编程核心技术》读后感（五）
哎呀妈呀脑壳疼脑壳疼
11-16 105
《Java多线程编程核心技术》读后感（五）       下面验证上面三条结论 验证第一条结论： package Second; public class MyObject { } package Second; public class Service { public void testMethod1...
《Java多线程编程核心技术》读后感（三）
哎呀妈呀脑壳疼脑壳疼
11-15 167
《Java多线程编程核心技术》读后感（三）   synchronized同步语句块 用synchronized声明方法在某些情况下是有弊端的，比如A线程调用同步方法执行以一个长时间的任务，那么B线程则必须等待比较较长的时间。在这样的情况下可以使用synchronized同步语句块来解决 synchronized方法的弊端 package Seco...
《多线程与高并发》读书笔记（一）
a816120的博客
07-15 206
请说出启动线程的三种方式 ?     你说第一个：new Thread().start()； 第二个: new Thread(Runnable).start() 这没问题 ；那第三个呢，要回答线程池也是用的这两种之一，他这么问有些吹毛求疵的意思，你就可以说通过线程池也可以启动 一个新的线程 3:Executors.newCachedThreadPool()或者FutureTask + Callable //启动线程的5种方式 public static void main(String[] args)
Java多线程编程核心技术_完整版_java_
09-30
本教程《Java多线程编程核心技术》将深入探讨这一主题。 一、线程的创建与启动 1. 继承Thread类：创建一个新的类，该类继承自Thread类，然后重写run()方法，最后创建该类的实例并调用start()方法启动线程。 2. 实现...
Java多线程编程核心技术.zip
09-24
本资料"Java多线程编程核心技术.zip"深入探讨了这些核心技术，并提供了源码供学习者实践和理解。 1. **线程的创建与启动** - 继承Thread类：自定义类继承Thread类，重写run()方法，然后创建该类对象并调用start()...
JAVA多线程编程技术PDF
08-28
这份“JAVA多线程编程技术PDF”是学习和掌握这一领域的经典资料，涵盖了多线程的全部知识点。 首先，多线程的核心概念包括线程的创建与启动。在Java中，可以通过实现Runnable接口或继承Thread类来创建线程。创建后...
【JAVA多线程】多线程编程核心技术学习资料
03-02
这份"Java多线程编程核心技术学习资料"正是针对这一主题提供的一份宝贵的学习资源，适合初、中级Java开发人员提升自己的多线程编程技能。 在Java中，多线程主要通过以下方式实现： 1. 继承Thread类：创建一个新的...
Java多线程编程技术
03-26
《Java多线程编程核心技术》建议猿友们读两遍，因为其写得没有那么抽象，第一遍有些概念不是很理解，可以先跳过并记录起来，第一遍阅读的目的主要是了解整个架构。第二遍再慢慢品味，并贯穿全部是指点来思考，并将...
《Java多线程编程核心技术》读后感（十二）
哎呀妈呀脑壳疼脑壳疼
11-18 132
《Java多线程编程核心技术》读后感（十二） 类ThreadLocal的使用 主要解决的是每个线程绑定自己的值，可以将ThreadLocal类比喻成全局存放数据的盒子，盒子中可以存储每个线程私有数据。 类ThreadLocal解决的是变量在不同线程间的隔离线，也就是不同线程拥有自己的值，不同线程中的值是可以放入ThreadLocal类中进行保存的 方法...
《Java多线程编程核心技术》读书笔记
lpckr94的博客
05-25 530
       多线程技术在Java中非常重要，整个Java多线程安全技术的发展是围绕着“可见性”与“原子性”两个主题发展的，Java的同步机制都是围绕这两个方面来保证线程安全。       多线程技术在Java中扮演着十分重要的角色。一 线程与进程的概念进程：广义上，可以理解为一个程序，如QQ，音乐，游戏等。线程：在进程中运行的子任务。当你打开QQ，你可以与他人聊天，可以下载文件，可以发送表情，那...
多线程学习心得
cauchy6317的博客
09-13 455
多线程的学习，不要求快，不要在意速度。任何一个事物的学习，基础永远是最重要的。所以，一开始求快，比如什么看 **天学会多线程 的书籍或视频。这些内容，往往都是直接说一个类中的几个方法的使用，大同小异，不会说为什么会有这个方法，这个类存在的意义，这个方法适合什么情况下使用？ 同时，因为这些内容讲究速成，就算老师懂，也不可能在短时间内讲清楚。更何况，大都数视频是半吊子。而且作为一个初学线程的人，不能很好地验证老师或书籍内容的对错。 所以我们在挑选多线程学习资料的时候，第一项就是书籍的厚薄，视频的长短。厚的书籍好
java线程编程核心技术_《Java多线程编程核心技术》读后感（十二）
weixin_29022821的博客
02-28 120
类ThreadLocal的使用主要解决的是每个线程绑定自己的值，可以将ThreadLocal类比喻成全局存放数据的盒子，盒子中可以存储每个线程私有数据。类ThreadLocal解决的是变量在不同线程间的隔离线，也就是不同线程拥有自己的值，不同线程中的值是可以放入ThreadLocal类中进行保存的方法get()与nullpackageThird;public classRun {public st...
Java多线程核心技术(一)：基础知识总结
supersnow0622的专栏
02-22 1859
概念 进程：进程是操作系统结构的基础，是一次程序的执行，是一个程序及其数据在处理机上顺序执行时所发生的活动，是程序在一个程序集合上运行的过程，它是系统进行资源分配和调度的一个基本单位。 线程：线程是进程中独立运行的子任务。使用多线程技术后，可以在同一时间运行更多不同种类的任务。 使用多线程 第一种方式：继承Thread类，并实现run方法 第二种方式：实现Runnable接口 注意：1
《java多线程编程核心技术》
huzhiqiangCSDN的博客
07-06 949
《java多线程编程核心技术》 为什么要使用多线程 a、提高系统的吞吐率。可以有多个并发的操作，如I/O处理、访问数据库等耗时操作会释放CPU时间片，使CPU可以处理其他线程。 b．提高响应性。异步执行任务，将耗时的操作丢给其他工作者线程执行，调用可以很快的收到响应并执行其他操作。 c、充分利用多核CPU。随着现代CPU的生产工艺从CPU主频频率转向多核化，即在一块芯片上集成多个CPU内核，因此多线程编程充分利用计算
好读书不求甚解(一)Java多线程编程核心技术
能写下来,理解才会更深
10-08 2352
第1章 Java多线程技能 第2章 对象及变量的并发访问 1 synchronized同步方法 2 synchronized同步代码块 3 volatile 第3章 线程间通信 1 等待通知机制 2 join方法 3 ThreadLocal类 第4章 Lock的使用 1 ReentrantLock类 2 ReentrantReadWriteLock类 第5章 定时器Timer 第6章 单例模式与多线
《Java多线程编程核心技术第二版》读书笔记
xiaosi的博客
11-19 620
一、总结 这本书写的很浅，更多的是案例，ThreadLocal部分还可以，原理基本讲到了 大致总结了下面部分知识点 二、内容 在什么情况下使用多线程？ 阻塞 依赖，如业务分为两个执行过程，当A业务阻塞的时候，B业务的执行不依赖A业务的执行结果 start()方法耗时的原因是因为执行了多个步骤 通过JVM告诉操作系统创建Thread 通过系统开辟内存并使用WindowsSDK中的createThread()函数创建Thread对象 操作系统对Thread对象进行调度，以确定执行时机 Thread在操作系
Java多线程编程核心技术详解与实战
"《Java多线程编程核心技术》是一本由高洪岩撰写的专著，作为'Java核心技术系列'的一部分，它深入探讨了Java多线程编程的关键技术和实践。本书旨在弥补市场上同类教材的不足，即缺乏对Java多线程技术的全面覆盖。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值