Java多线程编程核心技术阅读笔记(对象变量的并发访问)

于 2020-10-16 19:34:35 发布
阅读量100 收藏
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42913304/article/details/109091064
版权

2.1synchronized同步方法

非线程安全 会在多个线程对同一个对象中的实例变量进行并发访问时发生 产生的后果就是脏读也就是读到的数据其实是被改过的。 而线程安全就是以获得的实例变量的值是经过同步处理的 不会出现脏读现象

2.1.1 方法内的变量为线程安全
public class MethodSelf {
    public static  class ThreadA extends  Thread{
        private MethodSelf methodSelf;
        public ThreadA(MethodSelf methodSelf){
            this.methodSelf = methodSelf;
        }
        @Override
        public void run() {
            methodSelf.addI("a");
        }
    }
    public static  class ThreadB extends  Thread{
        private MethodSelf methodSelf;
        public ThreadB(MethodSelf methodSelf){
            this.methodSelf = methodSelf;
        }
        @Override
        public void run() {
            methodSelf.addI("b");
        }
    }
    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);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

    public static void main(String[] args) {
        MethodSelf thread = new MethodSelf();
        ThreadA threadA  = new ThreadA(thread);
        threadA.start();
        ThreadB threadB  = new ThreadB(thread);
        threadB.start();
    }
}

方法内得变量为线程安全
在这里插入图片描述

2.1.2 实例变量非线程安全

如果多个线程同时访问同一个实例变量则可能出现非线程安全问题
将num修改为实例变量再运行程序

   private int num = 0;

在这里插入图片描述

2.1.3 多个对象多个锁
public class MethodSelf {
    private int num = 0;
    public static class ThreadA extends Thread {
        private MethodSelf methodSelf;

        public ThreadA(MethodSelf methodSelf) {
            this.methodSelf = methodSelf;
        }

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

    public static class ThreadB extends Thread {
        private MethodSelf methodSelf;

        public ThreadB(MethodSelf methodSelf) {
            this.methodSelf = methodSelf;
        }

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

    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);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

    public static void main(String[] args) {
        MethodSelf thread1 = new MethodSelf();
        MethodSelf thread2 = new MethodSelf();
        ThreadA threadA = new ThreadA(thread1);
        threadA.start();
        ThreadB threadB = new ThreadB(thread2);
        threadB.start();
    }
}

上面是两个线程分别访问同一个类的两个不同的实例的同步方法 效果却以异步方式运行
从上面的程序来看 addI 方法使用synchronized关键字但打印的顺序不是同步的 关键字
synchronized取得的锁都是对象锁而不是把一段代码或方法当做锁 所以哪个线程先执行
带synchronized关键字的方法 哪个线程就持有该方法所属对象的锁LOCK 其它线程只能
呈等待状态 前提是多个线程访问的是同一个对象
在这里插入图片描述

2.1.4 synchronized 方法与锁对象
public class LockObject {
    public synchronized void  methodA(){
        try {
            System.out.println("begin" + Thread.currentThread().getName());
            Thread.sleep(5000);
            System.out.println("end");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static class ThreadA extends  Thread{
        private LockObject object;
        public ThreadA(LockObject object){
            this.object = object;
        }

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

    public static class ThreadB extends  Thread{
        private LockObject object;
        public ThreadB(LockObject object){
            this.object = object;
        }

        @Override
        public void run() {
            super.run();
            object.methodA();
        }
    }
    public static class Run{
        public static void main(String[] args) {
            LockObject object = new LockObject();
            ThreadA a = new ThreadA(object);
            a.setName("A");
            ThreadB b = new ThreadB(object);
            b.setName("B");
            a.start();
            b.start();
        }
    }
}

当A释放锁后B才执行 关键字synchronized 一定是排队运行的 只有共享资源的读写访问才需要同步化 如果不是共享资源那么更本没有同步的必要
在这里插入图片描述
其它方法被调用会是什么效果呢

public class LockObject {
    public synchronized void  methodA(){
        try {
            System.out.println("methodA begin" + Thread.currentThread().getName());
            Thread.sleep(5000);
            System.out.println("end");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public  void  methodB(){
        try {
            System.out.println("methodB begin" + Thread.currentThread().getName());
            Thread.sleep(5000);
            System.out.println("end");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public static class ThreadA extends  Thread{
        private LockObject object;
        public ThreadA(LockObject object){
            this.object = object;
        }

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

    public static class ThreadB extends  Thread{
        private LockObject object;
        public ThreadB(LockObject object){
            this.object = object;
        }

        @Override
        public void run() {
            super.run();
            object.methodA();
        }
    }
    public static class Run{
        public static void main(String[] args) {
            LockObject object = new LockObject();
            ThreadA a = new ThreadA(object);
            a.setName("A");
            ThreadB b = new ThreadB(object);
            b.setName("B");
            a.start();
            b.start();
        }
    }
}

在这里插入图片描述
methodB 方法加上 synchronized 关键字重新运行
在这里插入图片描述
A线程先持有对象的LOCK锁 B线程可以异步调用对象中非synchronized类型方法
A线程先持有对象的LOCK锁 B线程如果在这时调用synchronized类型的方法则需要等待

2.1.5 synchronized 锁重入

synchronized 拥有锁重入的功能 就是在使用synchronized时 当一个线程得到一个对象锁后 再次请求此对象时是可以再次得到该对象的锁

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

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

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

    public static class MyThreadA extends Thread{
        @Override
        public void run() {
            SynchronizedGo synchronizedGo = new SynchronizedGo();
            synchronizedGo.service1();
        }
    }

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

可重入锁的概念是 自己可以再次获取自己的内部锁 比如有条线程获得某个对象的锁 此时这个锁还没释放 当再次想要获取这个对象的锁的时候 还是可以获取的 如果不可重入的话 会造成死锁 当存在子父类继承关系时 子类是完全可以通过"可重入锁"调用父类的同步方法
在这里插入图片描述

2.1.6 出现异常 锁自动释放
package threadMain.chat2;

public class ThrowLock {
  synchronized   public  void testMethod(){
        if(Thread.currentThread().getName().equals("a")){
            System.out.println(Thread.currentThread().getName());
            int i = 1;
            while (i == 1){
                System.out.println("while");
                Integer.parseInt("a");
            }
        }else{
            System.out.println("B run");
        }
    }
    public static class ThreadA extends Thread{
      private  ThrowLock throwLock;
      public ThreadA(ThrowLock throwLock){
          this.throwLock = throwLock;
      }
        @Override
        public void run() {
            throwLock.testMethod();
        }
    }
    public static class ThreadB extends Thread{
      private  ThrowLock throwLock;
      public ThreadB(ThrowLock throwLock){
          this.throwLock = throwLock;
      }
        @Override
        public void run() {
            throwLock.testMethod();
        }
    }

    public static class Run{
        public static void main(String[] args) {
            ThrowLock throwLock = new ThrowLock();
            ThreadA a = new ThreadA(throwLock);
            a.setName("a");
            a.start();
            ThreadB b = new ThreadB(throwLock);
            b.setName("b");
            b.start();
        }
    }
}

线程A出现异常并释放锁 线程B进入方法正常打印 出现异常的锁被自动释放了
在这里插入图片描述

2.2 synchronized 同步语句块

用关键字synchronized 声明方法在某些情况下是有弊端的 比如A线程调用同步方法执行一个长时间的任务 那么B线程则必须等待比较长的时间 在这种情况可以使用同步块来解决

2.2.1 synchronized 同步块的使用

当两个并发线程访同一个对象Object中的synchronized (this) 一段时间内只能有一个宣线程被执行 另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块

package threadMain.chat2;

public class SynchronizedDemo {
    public void serviceMethod(){
        try {
            synchronized (this){
                System.out.println("begin");
                Thread.sleep(2000);
                System.out.println("end");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public static class ThreadA extends Thread{
        private SynchronizedDemo demo;
        public ThreadA(SynchronizedDemo  demo){
            this.demo = demo;
        }

        @Override
        public void run() {
            demo.serviceMethod();
        }
    }
    public static class ThreadB extends Thread{
        private SynchronizedDemo demo;
        public ThreadB(SynchronizedDemo  demo){
            this.demo = demo;
        }

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

    public static class Run{
        public static void main(String[] args) {
            SynchronizedDemo demo = new SynchronizedDemo();
            ThreadA a = new ThreadA(demo);
            a.setName("a");
            a.start();
            ThreadB b = new ThreadB(demo);
            b.setName("b");
            b.start();
        }

    }
}
2.1.2 用同步代码块解决同步方法弊端
    public  void doLongTimeTask(){
        try {
            System.out.println("begin task");
            Thread.sleep(3000);
            String privateGetData1 =  Thread.currentThread().getName();
            String privateGetData2 = Thread.currentThread().getName();
            synchronized (this){
                getDate1 = privateGetData1;
                getDate1 = privateGetData2;
            }
            System.out.println(getDate1);
            System.out.println(getDate2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
2.1.3 一半同步 一半异步

不在 synchronized 块中就是异步执行， 在 synchronized 块中就是同步执行。

package threadMain.chat2;

public class TaskDemo {
    public void doLongTimeTask() {
        for (int i = 0; i < 100; i++){
            System.out.println(Thread.currentThread().getName() + "i=" +(i + 1));
        }
        System.out.println("");
        synchronized (this){
            for (int i = 0; i < 100; i++){
                System.out.println(Thread.currentThread().getName()S + "i=" +(i + 1));
            }
        }



    }
    public static class MyThreadA extends Thread{
        private TaskDemo taskDemo;
        public MyThreadA(TaskDemo taskDemo){
            this.taskDemo = taskDemo;
        }

        @Override
        public void run() {
            taskDemo.doLongTimeTask();
        }
    }
    public static class MyThreadB extends Thread{
        private TaskDemo taskDemo;
        public MyThreadB(TaskDemo taskDemo){
            this.taskDemo = taskDemo;
        }

        @Override
        public void run() {
            taskDemo.doLongTimeTask();
        }
    }

    public static  class Run{
        public static void main(String[] args) {
            TaskDemo taskDemo = new TaskDemo();
            MyThreadA threadA = new  MyThreadA(taskDemo);
            threadA.start();
            MyThreadB threadB = new  MyThreadB(taskDemo);
            threadB.start();
        }
    }
}

在这里插入图片描述

2.1.4 synchronized 代码块间的同步性

当一个线程访问 object 的一个synchronized(this) 同步代码块时， 其他线程对同一个 object 中所有其他 synchronized(this) 同步代码块的访问将被阻塞， 这说明 synchronized 使用的 “对象监视器” 是一个

package threadMain.chat2;

public class SynchronizedDemo {
    public void serviceMethodA() {
        try {
            synchronized (this) {
                System.out.println("begin");
                Thread.sleep(2000);
                System.out.println("end");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

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

    public static class ThreadA extends Thread {
        private SynchronizedDemo demo;

        public ThreadA(SynchronizedDemo demo) {
            this.demo = demo;
        }

        @Override
        public void run() {
            demo.serviceMethodA();
        }
    }

    public static class ThreadB extends Thread {
        private SynchronizedDemo demo;

        public ThreadB(SynchronizedDemo demo) {
            this.demo = demo;
        }

        @Override
        public void run() {
            demo.serviceMethodB();
        }
    }

    public static class Run {
        public static void main(String[] args) {
            SynchronizedDemo demo = new SynchronizedDemo();
            ThreadA a = new ThreadA(demo);
            a.setName("a");
            a.start();
            ThreadB b = new ThreadB(demo);
            b.start();
            b.setName("b");
        }

    }
}

在这里插入图片描述
两个同步代码块按顺序执行

2.1.5 验证同步 synchronized(this)代码块是锁定当前对象的
package threadMain.chat2;

public class TaskDemo {
    public void otherTask(){
        System.out.println("---------------------");
    }
    public void doLongTimeTask() {
        synchronized (this){
            for (int i = 0; i < 100000; i++){
                System.out.println(Thread.currentThread().getName() + "i=" +(i + 1));
            }
        }



    }
    public static class MyThreadA extends Thread{
        private TaskDemo taskDemo;
        public MyThreadA(TaskDemo taskDemo){
            this.taskDemo = taskDemo;
        }

        @Override
        public void run() {
            taskDemo.doLongTimeTask();
        }
    }
    public static class MyThreadB extends Thread{
        private TaskDemo taskDemo;
        public MyThreadB(TaskDemo taskDemo){
            this.taskDemo = taskDemo;
        }

        @Override
        public void run() {
            taskDemo.otherTask();
        }
    }

    public static  class Run{
        public static void main(String[] args) throws InterruptedException {
            TaskDemo taskDemo = new TaskDemo();
            MyThreadA threadA = new  MyThreadA(taskDemo);
            threadA.start();
            Thread.sleep(100);
            MyThreadB threadB = new  MyThreadB(taskDemo);
            threadB.start();
        }
    }
}

在这里插入图片描述

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

多个线程调用同一个对象中的不同名称的synchronized同步方法或synchronized(this)同步代码块时 调用的效果就是按顺序执行 也就是同步的 阻塞的

package threadMain.chat2;

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() + "进入同步块");
                usernameParam = username;
                Thread.sleep(3000);
                passwordParam = password;
                System.out.println("线程" + Thread.currentThread().getName() + "离开同步块");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static class ThreadA extends Thread{
        private Service service;
        public ThreadA(Service  service){
            this.service = service;
        }

        @Override
        public void run() {
            service.setUsernamePassword("a","aa");
        }
    }
    public static class ThreadB extends Thread{
        private Service service;
        public ThreadB(Service  service){
            this.service = service;
        }

        @Override
        public void run() {
            service.setUsernamePassword("b","bb");
        }
    }
    public static class Run{
        public static void main(String[] args) {
            Service service = new Service();
            ThreadA threadA = new ThreadA(service);
            threadA.setName("A");
            threadA.start();
            ThreadB threadB = new ThreadB(service);
            threadB.setName("B");
            threadB.start();
        }
    }
}

在这里插入图片描述
锁非this对象具有一定的优点 如果一个类中有很多个synchronized 虽然能实现同步 但会受到阻塞 所以影响运行效率 但如果使用同步代码块锁非this对象则 synchronized(非this）代码块中的程序与同步方法是异步的 不会与其它锁this同步方法争抢this锁 大大提高运行效率


    public void setUsernamePassword(String username,String password){
         String anyString = new String();
        try {
            synchronized (anyString){
                System.out.println("线程" + Thread.currentThread().getName() + "进入同步块");
                usernameParam = username;
                Thread.sleep(3000);
                passwordParam = password;
                System.out.println("线程" + Thread.currentThread().getName() + "离开同步块");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

在这里插入图片描述
不是同步的而是异步 因为不是同一个锁 对象监视器必须是同一个对象 如果不是同一个对象监视器 结果就是异步调用了

package threadMain.chat2;

public class Service {
    private String usernameParam;
    private String passwordParam;

    public void a() {
        String anyString = new String();
        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");
    }

    public static class ThreadA extends Thread {
        private Service service;

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

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

    public static class ThreadB extends Thread {
        private Service service;

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

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

    public static class Run {
        public static void main(String[] args) {
            Service service = new Service();
            ThreadA threadA = new ThreadA(service);
            threadA.setName("A");
            threadA.start();
            ThreadB threadB = new ThreadB(service);
            threadB.setName("B");
            threadB.start();
        }
    }
}

在这里插入图片描述
由于对象监视器不同 所以运行结果就是异步的 同步代码块放在非同步synchronized 方法中进行声明 并不能保证调用方法的线程的执行同步/顺序性 也就是线程调用方法的顺序是无序的 虽然在同步块中执行的顺序是同步的 这样极易出现脏读问题

package threadMain.chat2;

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

public class ListDemo {
    private List list = new ArrayList<>();

    synchronized  public void add(String data){
        list.add(data);
    }
    synchronized  public int getSize(){
        return list.size();
    }

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

    public static class ThreadA extends Thread{
        private ListDemo listDemo ;
        public ThreadA(ListDemo listDemo){
            this.listDemo =listDemo;
        }
        @Override
        public void run() {
            MyService myService = new MyService();
            myService.addServiceMethod(listDemo,"a");
        }
    }

    public static class ThreadB extends Thread{
        private ListDemo listDemo ;
        public ThreadB(ListDemo listDemo){
            this.listDemo =listDemo;
        }
        @Override
        public void run() {
            MyService myService = new MyService();
            myService.addServiceMethod(listDemo,"b");
        }
    }
    public static class Run{
        public static void main(String[] args) {
            try {
                ListDemo listDemo = new ListDemo();
                ThreadA threadA = new ThreadA(listDemo);
                threadA.setName("A");
                threadA.start();
                ThreadB threadB = new ThreadB(listDemo);
                threadB.setName("B");
                threadB.start();
                Thread.sleep(6000);
                System.out.println("listsize =" + listDemo.getSize());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }
}

在这里插入图片描述
脏读出现了 出现的原因是两个线程以异步的方式返回List参数的size大小 解决方法就是同步化

2.2.7 细化3个结论

当多个线程调用synchronized 同步代码块时呈同步效果
当其他线程执行X对象中的synchronized同步方法时呈同步效果
当其他线程执行X对象方法里面的synchronized(this)代码块时也呈同步效果
如果其它线程调用不加synchronized 关键字的方法时 还是异步调用

2.2.8 静态同步synchronized 方法

关键字synchronized 还可以应用在static静态方法上 如果这样写就是对当前 *.java文件对应的class类进行持锁

package threadMain.chat2;

public class Service {
    private String usernameParam;
    private String passwordParam;

   synchronized public static void a() {
        String anyString = new String();
        try {
            synchronized (anyString) {
                System.out.println("a begin");
                Thread.sleep(3000);
                System.out.println("a end");
            }

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

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

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

    public static class ThreadA extends Thread {
        private Service service;

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

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

    public static class ThreadB extends Thread {
        private Service service;

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

        @Override
        public void run() {
            service.b();
        }
    }
    public static class ThreadC extends Thread {
        private Service service;

        public ThreadC(Service service) {
            this.service = service;
        }

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

    public static class Run {
        public static void main(String[] args) {
            Service service = new Service();
            ThreadA threadA = new ThreadA(service);
            threadA.setName("A");
            threadA.start();
            ThreadB threadB = new ThreadB(service);
            threadB.setName("B");
            threadB.start();
            ThreadC threadC = new ThreadC(service);
            threadC.setName("C");
            threadC.start();
        }
    }
}

异步原因是持有不同的锁 一个是对象锁 另一个是class锁 而class锁可以对类的所有对象实例起作用
在这里插入图片描述

package threadMain.chat2;

public class Service {
    private String usernameParam;
    private String passwordParam;

   synchronized public static void a() {
        String anyString = new String();
        try {
            synchronized (anyString) {
                System.out.println("a begin");
                Thread.sleep(3000);
                System.out.println("a end");
            }

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

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


    public static class ThreadA extends Thread {
        private Service service;

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

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

    public static class ThreadB extends Thread {
        private Service service;

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

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


    public static class Run {
        public static void main(String[] args) {
            Service service1 = new Service();
            Service service2 = new Service();
            ThreadA threadA = new ThreadA(service1);
            threadA.setName("A");
            threadA.start();
            ThreadB threadB = new ThreadB(service2);
            threadB.setName("B");
            threadB.start();

        }
    }
}

虽然是不同对象但静态的同步方法还是同步运行 同步synchronized(class)代码块的作用其实和synchronized static方法的作用一样
在这里插入图片描述

2.2.9 数据类型String的常量池特性

在JVM中具有String 常量池缓存的功能 将synchronized(String)同步块与String联合使用时 要注意常量池带来的一些例外

package threadMain.chat2;

public class StringDemo {
    public static void print(String stringParam){
        try {
            synchronized (stringParam){
                while (true){
                    System.out.println(Thread.currentThread().getName());
                    Thread.sleep(1000);
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public static class ThreadA extends Thread{
        private StringDemo stringDemo;
        public ThreadA(StringDemo stringDemo){
            this.stringDemo = stringDemo;
        }

        @Override
        public void run() {
            stringDemo.print("AA");
        }
    }
    public static class ThreadB extends Thread{
        private StringDemo stringDemo;
        public ThreadB(StringDemo stringDemo){
            this.stringDemo = stringDemo;
        }

        @Override
        public void run() {
            stringDemo.print("AA");
        }
    }

    public static class Run{
        public static void main(String[] args) {
            StringDemo stringDemo = new StringDemo();
            ThreadA threadA = new ThreadA(stringDemo);
            threadA.setName("A");
            threadA.start();
            ThreadB threadB = new ThreadB(stringDemo);
            threadB.setName("B");
            threadB.start();
        }
    }
}

执行结果死循环 因为String的两个值都是AA 两个线程持有相同的锁 所以造成B不能执行 因此在大多数的情况 同步代码块都不使用String作为锁对象 而改用其它 比如实例化一个Object对象 当它并不放入缓存中
在这里插入图片描述

package threadMain.chat2;

import java.util.Objects;

public class StringDemo {
    public static void print(Object object){
        try {
            synchronized (object){
                while (true){
                    System.out.println(Thread.currentThread().getName());
                    Thread.sleep(1000);
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public static class ThreadA extends Thread{
        private StringDemo stringDemo;
        public ThreadA(StringDemo stringDemo){
            this.stringDemo = stringDemo;
        }

        @Override
        public void run() {
            stringDemo.print(new Object());
        }
    }
    public static class ThreadB extends Thread{
        private StringDemo stringDemo;
        public ThreadB(StringDemo stringDemo){
            this.stringDemo = stringDemo;
        }

        @Override
        public void run() {
            stringDemo.print(new Object());
        }
    }

    public static class Run{
        public static void main(String[] args) {
            StringDemo stringDemo = new StringDemo();
            ThreadA threadA = new ThreadA(stringDemo);
            threadA.setName("A");
            threadA.start();
            ThreadB threadB = new ThreadB(stringDemo);
            threadB.setName("B");
            threadB.start();
        }
    }
}

在这里插入图片描述

2.2.10 同步synchronized 方法无限等待与解决

同步方法容易造成死循环

package threadMain.chat2;

public class Service {
   synchronized public static void a() {
       System.out.println("a begin");
       boolean is = true;
       while (is){
       }
       System.out.println("a end");
    }

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


    public static class ThreadA extends Thread {
        private Service service;

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

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

    public static class ThreadB extends Thread {
        private Service service;

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

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


    public static class Run {
        public static void main(String[] args) {
            Service service1 = new Service();
            Service service2 = new Service();
            ThreadA threadA = new ThreadA(service1);
            threadA.setName("A");
            threadA.start();
            ThreadB threadB = new ThreadB(service2);
            threadB.setName("B");
            threadB.start();

        }
    }
}

线程B 永远得不到运行的机会 锁死了
这时可以用同步块来解这样的问题

package threadMain.chat2;

public class Service {
    static Object object1 = new Object();
    public static void a() {
        synchronized (object1){
            System.out.println("a begin");
            boolean is = true;
            while (is) {
            }
            System.out.println("a end");
        }
    }
    static Object object2 = new Object();
    public static void b() {
        synchronized (object2){
            System.out.println("b begin");
            System.out.println("b end");
        }

    }


    public static class ThreadA extends Thread {
        private Service service;

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

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

    public static class ThreadB extends Thread {
        private Service service;

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

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


    public static class Run {
        public static void main(String[] args) {
            Service service1 = new Service();
            Service service2 = new Service();
            ThreadA threadA = new ThreadA(service1);
            threadA.setName("A");
            threadA.start();
            ThreadB threadB = new ThreadB(service2);
            threadB.setName("B");
            threadB.start();

        }
    }
}

不再出现同步等待情况
在这里插入图片描述

2.3 Volatile 关键字

Volatile 的主要作用是使变量在多个线程间可见

2.3.1 关键字volatile与死循环
package threadMain.chat2;

import com.sun.org.apache.regexp.internal.RE;

public class VolatileDemo {
    private boolean isContinuePrint = true;
    public boolean isContinuePrint(){
        return isContinuePrint;
    }

    public void setContinuePrint(boolean continuePrint) {
        isContinuePrint = continuePrint;
    }
    public void printStringMethod(){
        try {
            while (isContinuePrint == true){
                System.out.println("run " + Thread.currentThread().getName());
                Thread.sleep(1000);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public static class Run{
        public static void main(String[] args) {
            VolatileDemo volatileDemo = new VolatileDemo();
            volatileDemo.printStringMethod();
            System.out.println("我要停止它" + Thread.currentThread().getName());
            volatileDemo.setContinuePrint(false);
        }
    }
}

main线程一直在处理while()循环 导致程序不能执行后面的代码
在这里插入图片描述

2.3.2 解决同步死循环
package threadMain.chat2;

import com.sun.org.apache.regexp.internal.RE;

public class VolatileDemo implements Runnable{
    private boolean isContinuePrint = true;
    public boolean isContinuePrint(){
        return isContinuePrint;
    }

    public void setContinuePrint(boolean continuePrint) {
        this.isContinuePrint = continuePrint;
    }
    public void printStringMethod(){
        try {
            while (isContinuePrint == true){
                System.out.println("run " + Thread.currentThread().getName());
                Thread.sleep(1000);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        printStringMethod();
    }

    public static class Run{
        public static void main(String[] args) {
            VolatileDemo volatileDemo = new VolatileDemo();
            new Thread(volatileDemo).start();
            System.out.println("我要停止它" + Thread.currentThread().getName());
            volatileDemo.setContinuePrint(false);
        }
    }
}

在这里插入图片描述

2.3.3. 解决异步死循环
package threadMain.chat2;

import com.sun.org.apache.regexp.internal.RE;

public class VolatileDemo extends Thread{
    private boolean isContinuePrint = true;
    public boolean isContinuePrint(){
        return isContinuePrint;
    }

    public void setContinuePrint(boolean continuePrint) {
        this.isContinuePrint = continuePrint;
    }
    public void printStringMethod(){
        try {
            while (isContinuePrint == true){
                System.out.println("run " + Thread.currentThread().getName());
                Thread.sleep(1000);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        System.out.println("进入Run了");
        while (isContinuePrint == true){

        }
        System.out.println("线程被停止了");
    }

    public static class Run{
        public static void main(String[] args) {
            try {
                VolatileDemo volatileDemo = new VolatileDemo();
                volatileDemo.start();
                Thread.sleep(1000);
                volatileDemo.setContinuePrint(false);
                System.out.println("已经赋值为false");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

已经赋值为false但还是死循环 因为变量isContinuePrint 存在公共堆栈及线程的私有堆栈中 在JVM被设置-server 模式时为线程运行的效率 线程一直在私有堆栈中取得isContinuePrint 值是ture 代码 volatileDemo.setContinuePrint(false)虽然被执行 更新的却是公共堆栈中的isContinuePrint变量值所以一直为死循环状态
在这里插入图片描述

这个问题其实就是私有堆栈中的值和公共堆栈中的值不同步造成的。 解决这样的问题就
要使用 volatile 关键字了 它主要的作用就是当线程访问 isRimning 这个变量时 强制性从公
共堆栈中进行取值

  private volatile boolean isContinuePrint = true;

通过使用 volatile 关键字 强制的从公共内存中读取变量的值 使用 volatile 关键字增加了实例变量在多个线程之间的可见性 但 volatile 关键字最致命的缺点是不支持原子性

synchronized 和 volatile的区别
1 关键字 volatile 是线程 M 步的轻量级实现 所以 volatile 性能肯定比 synchronized 要好 并且 volatile 只能修饰于变量 而 synchronized 可以修饰方法 以及代码块
2 多线程访问 volatile 不会发生阻塞 而 synchronized 会出现阻塞
3 volatile 能保证数据的可见性， 但不能保证原子性； 而 synchronized 可以保证原子性也可以间接保证可见性
4 关键字 volatile 解决的是变量在多个线程之间的可见性 而 synchronized关键字解决的是多个线程之间访问资源的同步性。

2.3.4 volatile非原子的特性
package threadMain.chat2;

public class VolatileTe extends Thread {
    volatile  public static int count;
    private static void addCount(){
        for (int i = 0; i < 100; i ++){
            count++;
        }
        System.out.println("count=" + count);
    }

    @Override
    public void run() {
        addCount();
    }

    public static class Run{
        public static void main(String[] args) {
            VolatileTe[] volatileTes = new VolatileTe[100];
            for (int i = 0; i < 100; i ++){
                volatileTes[i] = new VolatileTe();
            }
            for (int i = 0; i < 100; i ++){
                volatileTes[i].start();
            }
        }
    }
}

运行结果不是10000
在这里插入图片描述

加上synchronized

synchronized private static void addCount() {
        for (int i = 0; i < 100; i++) {
            count++;
        }
        System.out.println("count=" + count);
    }

在这里插入图片描述
如果在方法 private static void addCount()前加人 synchronized 同步关键字， 也就没有必要再使用 volatile 关键字来声明 count 变量了关键字 volatile 主要使用的场合是在多个线程中可以感知实例变量被更改了 并且可以获得最新的值使用 也就是用多线程读取共享变量时可以获得最新值使用 所以说 volatile 本身并不处理数据的原子性， 而是强制对数据的读写及时影响到主内存的

2.3.5 synchronized 代码块有 volatile 同步的功能
package threadMain.chat2;


public class VolatileDemo extends Thread{
    private  boolean isContinuePrint = true;
    public void printStringMethod(){
            while (isContinuePrint == true){

            }
            System.out.println("停下来了");

    }
    public void stopMethod(){
        isContinuePrint = false;
    }

    public static  class ThreadA extends Thread{
        private VolatileDemo volatileDemo;
        public ThreadA(VolatileDemo volatileDemo){
            this.volatileDemo = volatileDemo;
        }

        @Override
        public void run() {
            volatileDemo.printStringMethod();
        }
    }
    public static  class ThreadB extends Thread{
        private VolatileDemo volatileDemo;
        public ThreadB(VolatileDemo volatileDemo){
            this.volatileDemo = volatileDemo;
        }

        @Override
        public void run() {
            volatileDemo.stopMethod();
        }
    }

    public static class Run{
        public static void main(String[] args) {
            try {
                VolatileDemo volatileDemo = new VolatileDemo();
                ThreadA a = new ThreadA(volatileDemo);
                a.start();
                Thread.sleep(1000);
                ThreadB b = new ThreadB(volatileDemo);
                b.start();
                System.out.println("发起停止命令");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

已经发起停止命令但还是死循环 这就i是各个线程间的数据值没有可视性造成的 而关键字 synchronized 可以具有可视性。
在这里插入图片描述

    public void printStringMethod(){
        String str = new String();
            while (isContinuePrint == true){
                synchronized (str){

                }
            }
            System.out.println("停下来了");

    }

关键字 synchronized 可以保证在同一时刻， 只有一个线程可以执行某一个方法或某一个代码块。 它包含两个特征： 互斥性和可见性。 同步 synchronized 不仅可以解决一个线程看到对象处于不一致的状态， 还可以保证进入同步方法或者同步代码块的每个线程， 都看到由同一个锁保护之前所有的修改效果。

qq_42913304
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java线程之线程同步
03-04 9349
线程同步    多线程的使用为我们的程序提供了众多的方便，同时它也给我们带来了以往没有考虑过的麻烦。当我们使用多线程处理共享资源时意外将会发生：比如我们一起外出就餐，每个人都是一个线程，餐桌上的食物则是共享资源，当我看到红烧鸡腿上桌后立即拿起筷子直奔目标，眼看着就得手的时候，突然～～～鸡腿消失了，一个距离盘子更近的线程正在得意地啃着。为了避免上述问题的发生，Java为我们提供了“synch
多线程工作请求的同步
红金鱼的专栏
06-30 1971
本文用代码说明如何将不同线程上的工作请求进行缓存并同步到同一个线程上，其目主要有两个： 减少并发线程，节省系统管理线程的资源消耗。 避免对共享数据加锁，简化后续处理工作的程序逻辑。在开发服务器的时候经常会遇到客户端从不同的线程上向服务器发出工作请求的情况，根据业务规则的要求，通常都会对共享的数据进行读写，这就需要对进行线程访问的数据加锁，但加锁会在很大程度上增加程序
关于post()方法运行在哪个线程中
zhuhai__yizhi的专栏
09-14 2304
android中我们常用的post(new Runnable(){//...})有两种。 （1）view的post方法，运行在UI线程中，也就是主线程中。 （2）handler里面的方法运行在handler依附的线程中，可能是主线程，也可能是其他线程。 下面是Handler里面的post方法： /** * Causes the Runnable r to be added
多线程之线程同步问题
Will_Zhan的博客
08-06 246
CPU的一次操作必须是原子性的，想象一下多个窗口卖同一时段同一个电影的电影票的例子（共享数据源），当一个线程再买票，计算剩余票数和显示剩余票数的时候，其他窗口不能进行这些操作，如果多个窗口同时操作就会出现问题，例如窗口2卖完票剩下100张，窗口2先卖票，然后计算计算剩余票数为100张，在显示剩余票数前，窗口1也卖出去了一张票，此时实际剩下99张，窗口2显示的时候还是刚才计算的100张。如何解决线程...
主线程 子线程 同步请求 异步请求
zhengyongbo的博客
05-04 2165
昨天小编突然想到一个问题，那就是主线程避免进行耗时操作，我想到 好像我的请求网络操作都是在主线程中进行的啊，后来一想不对啊，如果都是在主线程中进行的，应用早不可以用了，经过小编的试验得出下面结论，特此记录一下： 1 同步请求必须另开线程，否则报错：android.os.NetworkOnMainThreadException 2 异步请求本身就已经开启了新的线程，所以在写在应用生命周期中没
JAVA并发编程实践-线程安全-学习笔记
最新发布
07-20
在Java并发编程中，线程安全是一个至关重要的概念，它涉及到多线程环境下对共享数据的正确管理和访问。线程安全意味着当多个线程同时访问一个对象或数据时，对象的状态能够保持一致性和完整性，不会因为并发导致数据...
Java并发编程学习笔记
04-11
Java并发编程是Java开发中必不可少的一部分，涉及到多线程、同步机制、线程池以及并发工具类等多个核心知识点。以下是对这些主题的详细说明： 1. **线程安全与锁 Synchronized 底层实现原理**： 线程安全是指在多...
Java 并发编程学习笔记之核心理论基础
09-02
Java自诞生以来就内置了对多线程的支持，使得开发者能够轻松创建并行运行的任务，提升程序性能。然而，随着并发编程实践的深入，我们发现实现并发编程不仅仅是简单的线程创建和同步那么简单，它涉及到许多复杂的核心...
读书笔记-Java并发编程实战-基础篇
08-09
在Java并发编程领域，确保代码的线程安全性和数据的一致性是至关重要的。...在编写并发应用时，遵循上述核心知识点，能够帮助开发者编写出既高效又可靠的多线程代码，从而满足Java并发编程的需求。
并发并行同步异步多线程的区别
刘 争
02-17 8999
同步和异步的概念: 同步:同步就是指一个进程在执行某个请求的时候，若该请求需要一段时间才能返回信息，那么这个进程将会一直等待下去，直到收到返回信息才继续执行下去 异步:异步是指进程不需要一直等下去，而是继续执行下面的操作，不管其他进程的状态。当有消息返回时系统会通知进程进行处理，这样可以提高执行的效率。 并发 并行 同步 异步 多线程的区别 1.并发：在操作系统中，是指一个时间段中有几个程
同步线程和异步线程的区别
热门推荐
奋斗ing
10-10 3万+
1：同步可以看做是一个单线程操作，只要客户端请求了，在服务器没有反馈信息之前是一个线程阻塞状态（就是假死状态，不能操作其他方法）。 2：异步肯定是个多线程。在客户端请求时，可以执行其他线程，并且在把这个线程存放在他的队列里面，有序的执行。（可以设置线程的数量，当超过最大时会显示等待状态）。 线程同步与异步区别 线程同步是多个线程同时访问同一资源，等待资源访
线程同步
wangjunke的专栏
06-04 1550
在前面的文章中，所涉及的线程大多都是独立的，而且异步执行。也就是说每个线程都包含了运行时自身所需要的数据或方法，而不需要外部的资源或方法，也不必关心其他线程的状态或行为。但是，有时候在进行多线程的程序设计中需要实现多个线程共享同一段代码，从而实现共享同一个私有成员或类的静态成员的目的。这时，由于线程和线程之间互相竞争CPU资源，使得线程无序地访问这些共享资源，最终可能导致无法得到正确的结果。例如，
线程同步的三种实现方式
xichengxml的博客
12-01 8418
java线程的同步问题可以通过三种方式实现： 首先创建四个线程： public class Test01 { public static void main(String[] args) { //创建接口实现类实例化对象 Runnable r1 = new TicketRunnableImpl(); //创建线程 Thread t1 = new Thread(r1, "窗口一
同步请求和异步请求的区别
weixin_30251829的博客
09-17 416
同步请求和异步请求的区别 先解释一下同步和异步的概念 同步是指：发送方发出数据后，等接收方发回响应以后才发下一个数据包的通讯方式。 异步是指：发送方发出数据后，不等接收方发回响应，接着发送下个数据包的通讯方式。 同步通信方式与异步通信的概念 同步通信方式要求通信双方以相同的时钟频率进行，而且准确协调，通过共享一个单个时钟或定时脉冲源保证发送方和接收方的准确同步，效率较...
初探队列消息：普通http同步请求、基于线程池的异步请求、基于消息队列的请求三者的比较
superyu1992的专栏
08-31 5645
最近忙完了手头的项目，终于有时间研究之前一直落下的消息队列了，顺带手又看了一下多线程异步请求，加上最传统的http同步请求，正好可以拉出来做个比较，废话不多说，走起！ 场景设计：三个用户同时向系统发送一个请求，要求系统进行处理； 通过这个场景设计，我们来看看不同请求方式的表现： 1、普通http同步请求：系统同时接收到了这三个请求，由于是同步方式，因此需要按顺序分别处理用户1、用户2、用户3...
什么是同步请求和异步请求？
ZZULI_星.夜
07-20 2万+
一、同步、异步请求 浏览器发送请求给服务器，其有同步请求和异步请求两种方式。 1同步请求 什么叫同步请求呢？ 就是在发送一个请求之后，需要等待服务器响应返回，才能够发送下一个请求。 之前学的请求是通过浏览器地址栏发送请求，这种方式就是属于同步请求。 但是其有两个缺陷： ①请求必须要等待响应 如果遇到请求阻塞，网络延迟，用户需要等待，这样用户体验效果不好。 ②请求时会携带所有的信息 比如说一个form表单，需要填入用户名，密码，手机号，等多个信息。 如果其中有一个信息填写错了，请求失败，又要全部重新填写，会很
多线程并发访问同一个对象时发生死锁的反思
镜头中的艺术
07-25 5937
来源：http://blog.csdn.net/lezhiyong      背景：SipPhone终端与多个其他设备的用户视频互通，由于Sip终端只能显示一路视频，所以模块A采用轮询方式将多个用户视频发送到sip终端上。模块A同时允许手动打开/关闭其中一个用户的视频，当该用户视频打开时候同时选送到sip终端显示。用户视频采用H264编码，Sip终端接收H263编码视频，所以用户视频需要经过H
ajax中同步和异步的区别
一身都是月
06-18 1068
Web请求中同步与异步的区别 2010-12-15 普通的B/S模式就是同步，而AJAX技术就是异步，当然XMLHttpReques有同步的选项。 同步：提交请求->等待服务器处理->处理完毕返回。这个期间客户端浏览器不能干任何事。 异步: 请求通过事件触发->服务器处理（这是浏览器仍然可以作其他事情）->处理完毕。 举个生动的例子吧： 同步就是你叫我去吃饭
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值