Java线程间共享实现方法详解

一、synchronize对象锁和类锁

synchronize为多线程关键字是一种同步锁,它可以修饰以下几种对象:

代码块:被修饰的代码块被称为同步代码块,作用的范围是{}里面的代码,作用的对象是调用这个代码块的对象

方法:被修饰的方法称为同步方法,作用的范围是整个方法,作用的对象是调用这个方法的对象

类:作用的范围是synchronize后面括号里的部分,作用的对象是当前这个类

1、对象锁

下面由一个栗子引入:

public class TestSynchronize {
  //加了对象锁的方法
  private synchronized void syn(){
    //自定义sleep工具类
    SleepTools.second(2);
    System.out.println("syn is going..."+this.toString());
    SleepTools.second(2);
    System.out.println("syn ended..."+this.toString());
  }

  //调用了对象锁方法的线程1
  private static class thread implements Runnable{
    private TestSynchronize testSynchronize;
    public thread(TestSynchronize testSynchronize){
      this.testSynchronize = testSynchronize;
    }
    @Override
    public void run() {
      System.out.println("thread is running...");
      testSynchronize.syn();
    }
  }
  //调用了对象锁方法的线程2
  private static class thread2 implements Runnable{
    private TestSynchronize testSynchronize;
    public thread2(TestSynchronize testSynchronize){
      this.testSynchronize = testSynchronize;
    }
    @Override
    public void run() {
      System.out.println("thread2 is running...");
      testSynchronize.syn();
    }
  }
  public static void main(String[] args) {
    TestSynchronize testSynchronize = new TestSynchronize();
    thread thread = new thread(testSynchronize);

    TestSynchronize testSynchronize2 = new TestSynchronize();
    thread2 thread2 = new thread2(testSynchronize);
    //thread2 thread2 = new thread2(testSynchronize2);
    new Thread(thread).start();
    new Thread(thread2).start();
  }
}

/**
当两个线程都将testSynchronize传入时(即使用同一个对象调用加了对象锁的方法)运行结果如下:
thread is running...
thread2 is running...
syn is going...com.zl.synchronize.TestSynchronize@6b52350c
syn ended...com.zl.synchronize.TestSynchronize@6b52350c
syn is going...com.zl.synchronize.TestSynchronize@6b52350c
syn ended...com.zl.synchronize.TestSynchronize@6b52350c
*/

/**
当一个传入testSynchronize,另一个传入testSynchronize2时 运行结果如下:
thread is running...
thread2 is running...
syn is going...com.zl.synchronize.TestSynchronize@28835f5f
syn is going...com.zl.synchronize.TestSynchronize@47c48106
syn ended...com.zl.synchronize.TestSynchronize@28835f5f
syn ended...com.zl.synchronize.TestSynchronize@47c48106
*/

结论:多个线程调用同一个对象的同步方法会阻塞,调用不同对象的同步方法不会阻塞

2、类锁

1) synchronized修饰的静态方法

public static synchronized void obj3() {
  int i = 5;
  while (i-- > 0) {
    System.out.println(Thread.currentThread().getName() + " : " + i);
    try {
      Thread.sleep(500);
    } catch (InterruptedException ie) {
    }
  }
}

2) synchronized (test.class) ,锁的对象是test.class,即test类的锁。

public void obj1() {
  synchronized (test.class) {
    int i = 5;
    while (i-- > 0) {
      System.out.println(Thread.currentThread().getName() + " : " + i);
      try {
        Thread.sleep(500);
      } catch (InterruptedException ie) {
      }
    }
  }
}

那么问题来了:在一个类中有两方法,分别用synchronized 修饰的静态方法(类锁)和非静态方法(对象锁)。多线程访问两个方法的时候,线程会不会阻塞?

答案是当类锁和对象锁同时存在时,多线程访问时不会阻塞,因为他们不是一个锁。

二、volatile

volatile 是一个类型修饰符。volatile 的作用是作为指令关键字,确保本条指令不会因编译器的优化而省略。

​ volatile的特性

  • 保证了不同线程对这个变量进行操作时的可见性,即一个线程修改了某个变量的值,这新值对其他线程来说是立即可见的。(实现可见性)
  • 禁止进行指令重排序。(实现有序性)
  • volatile 只能保证对单次读/写的原子性。i++ 这种操作不能保证原子性。

三、ThreadLocal

  • ThreadLocal从字面意思来理解,是一个线程本地变量,也可以叫线程本地变量存储。有时候一个对象的变量会被多个线程所访问,这个时候就会有线程安全问题,当然可以使用synchronized关键字来为该变量加锁,进行同步处理来限制只能有一个线程来使用该变量,但是这样会影响程序执行的效率,这时ThreadLocal就派上了用场;
  • 使用ThreadLocal维护变量的时候,会为每一个使用该变量的线程提供一个独立的变量副本,即每个线程内部都会有一个当前变量。这样同时有多个线程访问该变量并不会相互影响,因为他们都是使用各自线程存储的变量,所以不会存在线程安全的问题。
  • 同步机制采用了“以时间换空间”的方式,而ThreadLocal采用了“以空间换时间”的方式,前者仅提供一份变量,让不同的线程排队访问,而后者为每一个线程都提供了一份变量,因此可以同时访问且互不影响。

下面给出测试程序:

public class ThreadLocalDemo {
  private static ThreadLocal<Integer> number = new ThreadLocal<Integer>(){
    @Override
    protected Integer initialValue() {
      return 1;
    }
  };
  private static class thread extends Thread{
    @Override
    public void run() {
      Integer number = ThreadLocalDemo.number.get();
      for (int i = 0; i < this.getId(); i++) {
        number++;
      }
      System.out.println(this.getName()+"---"+this.getId()+"===="+number);
    }
  }
  private static class thread2 extends Thread{
    @Override
    public void run() {
      Integer number = ThreadLocalDemo.number.get();
      for (int i = 0; i < this.getId(); i++) {
        number++;
      }
      System.out.println(this.getName()+"---"+this.getId()+"===="+number);
    }
  }
  public static void main(String[] args) {
    new Thread(new thread()).start();
    new Thread(new thread2()).start();
  }
}
/**
Thread-0---12====13
Thread-2---14====15
*/

四、等待(Wait)和通知(notify)

为了支撑多线程之间的协作,JDK提供了两个非常重要的线程接口:等待wait()方法和通知notify()方法。 这两个方法并不是在Thread类中的,而是输出在Object类。这意味着任何对象都可以调用这两个方法。

等待/通知的经典范式

wait()方法和notify()方法究竟是如何工作的呢?

  如果一个线程调用了object.wait()方法,那么它就会进入object对象的等待队列,这个队列中,可能会有多个线程,因为系统运行多个线程同时等待某一个对象,

  当object.notify()方法被调用的时候,它就会从这个等待队列中随机选择一个线程,并进行唤醒。

  除notity()方法外,Object对象还有一个类似的notifyAll()方法,它和notity方法的功能基本一致,不同的是,它会唤醒在这个等待队列中所有等待的线程,而不是随机一个。

  object.wait()方法并不能随便调用。它必须包含在对象的synchronzied语句中,无论是wait()方法或者notity()方法都需要首先获得目标对象的一个监视器。

​ 假设有T1和T2表示两个线程,T1在正确执行wait()方法前,必须获得object对象的监视器,而wait()方法执行之后会释放这个监视器。

这样做的目的是使其他等待在object对象上的线程不至于因为T1的休眠而全部无法正常执行。

  线程T2在notity()方法调用前,也必须获得object对象的监视器。此时T1已经释放了这个监视器。所以T2可以顺利获得object对象的监视器。

接着,T2执行了notify()方法尝试唤醒一个等待线程,这里假设唤醒了T1,T1被唤醒后,要做的第一件事并不是执行后续代码,而是要尝试重新

获得object对象的监视器,而这个监视器也正是T1在wait()方法执行前所持有的那个。

如果暂时无法获得,则T1还必须等待这个监视器。当监视器顺利获得后,T1才可以在真正意义上继续执行。

这里要注意,只有当wait()和notify()被包含的synchronized语句执行完,才会释放监视器。

为了方便理解,简单的案例:

public class testWaitAndNotify {
  final static Object object = new Object();

  public static class T1 extends Thread {
    public void run() {
      synchronized (object) {
        try {
          System.out.println(System.currentTimeMillis() + ":T1 start! ");
          System.out.println(System.currentTimeMillis() + ":T1 wait for object");
          object.wait();
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
        System.out.println(System.currentTimeMillis() + ":T1 end! ");
      }
    }
  }

  public static class T2 extends Thread {
    public void run() {
      synchronized (object) {
        try {
          System.out.println(System.currentTimeMillis() + ":T2 start! notify one thread");
          object.notify();
          sleep(5000);
          System.out.println(System.currentTimeMillis() + ":T2 end! ");
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }
    }
  }

  public static void main(String[] args) {
    Thread t1 = new T1();
    Thread t2 = new T2();
    t1.start();
    t2.start();
  }
}
/**
1571039516250:T1 start!
1571039516250:T1 wait for object
1571039516251:T2 start! notify one thread
1571039521251:T2 end!
1571039521251:T1 end!
*/

五、等待超时模式

由于经典的等待/通知范式无法做到超时等待,也就是说,当消费者在获得锁后,如果条件不满足,等待生产者改变条件之前会一直处于等待状态,在一些实际应用中,会浪费资源,降低运行效率。

伪代码如下所示:

//假设超时时间是mills,则等待持续时间是remaining,超时时间是future
long future = System.currentTimeMillis() + mills;
long remaining = mills;
synchronized (lock) {
  while (!condition && remaining > 0) {
    wait(remaining);
    remaining = future - System.currentTimeMillis();
  }
  //处理代码
}

六、join()

join在线程里面意味着“插队”,哪个线程调用join代表哪个线程插队先执行——但是插谁的队是有讲究了,不是说你可以插到队头去做第一个吃螃蟹的人,而是插到在当前运行线程的前面,比如系统目前运行线程A,在线程A里面调用了线程B.join方法,则接下来线程B会抢先在线程A面前执行,等到线程B全部执行完后才继续执行线程A。

话不多说上代码

public class TestJoin {
  private static class thread extends Thread{
    private Thread t;
    //接收一个插队线程
    public thread(Thread t){
      this.t = t;
    }
    @Override
    public void run() {
      try {
        //调用插队线程的join方法
        t.join();
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
      System.out.println(getName()+"---执行完毕!");
    }
  }
  public static void main(String[] args) throws InterruptedException {
    //获取当前线程作为前一个线程
    Thread pre = Thread.currentThread();
    //创建五个线程
    for (int i = 0; i < 5; i++) {
      Thread thread = new Thread(new thread(pre),String.valueOf(i));
      //启动线程
      thread.start();
      //重置前一个线程
      pre = thread;
    }
    System.out.println(System.currentTimeMillis());
    //让主线程睡眠2s
    Thread.currentThread().sleep(2000);
    System.out.println(System.currentTimeMillis());
    System.out.println(Thread.currentThread().getName()+"---执行完毕");
  }
}

/**
1571061168064
1571061170065
main---执行完毕
Thread-0---执行完毕!
Thread-1---执行完毕!
Thread-2---执行完毕!
Thread-3---执行完毕!
Thread-4---执行完毕!
*/

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们。

(0)

相关推荐

  • Java多线程编程之访问共享对象和数据的方法

    多个线程访问共享对象和数据的方式有两种情况: 1.每个线程执行的代码相同,例如,卖票:多个窗口同时卖这100张票,这100张票需要多个线程共享. 2.每个线程执行的代码不同,例如:设计四个线程,其中两个线程每次对j增加1,另外两个线程每次对j减少1. a.如果每个线程执行的代码相同,可以使用同一个Runnable对象,这个对象中有共享数据.卖票就可以这样做,每个窗口都在做卖票任务,卖的票都是同一个数据(点击查看具体案例). b.如果每个线程执行的代码不同,就需要使用不同的Runnable对象,有

  • Java多线程编程之ThreadLocal线程范围内的共享变量

    模拟ThreadLocal类实现:线程范围内的共享变量,每个线程只能访问他自己的,不能访问别的线程. package com.ljq.test.thread; import java.util.HashMap; import java.util.Map; import java.util.Random; /** * 线程范围内的共享变量 * * 三个模块共享数据,主线程模块和AB模块 * * @author Administrator * */ public class ThreadScopeS

  • Java线程重复执行以及操作共享变量的代码示例

    1.题目:主线程执行10次,子线程执行10次,此过程重复50次 代码: package com.Thread.test; /* * function:主线程执行10次,子线程执行10次, * 此过程重复50次 */ public class ThreadProblem { public ThreadProblem() { final Business bus = new Business(); new Thread(new Runnable() { public void run() { for

  • Java局部变量线程安全原理分析

    这篇文章主要介绍了Java局部变量线程安全原理分析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 方法调用栈结构: 每个线程都有自己独立的方法调用栈: 这种局部变量不共享,从而保证线程安全的技术,称为线程封闭技术. 案例:数据库连接池.采用线程封闭技术,线程获取的数据库连接connection,是独立的,在这个线程在关闭获取的这个connection之前,不会再分配给其他线程. 思考:递归调用太深,可能导致栈溢出. 栈溢出原因: 因为每调用一个

  • Java编程多线程之共享数据代码详解

    本文主要总结线程共享数据的相关知识,主要包括两方面:一是某个线程内如何共享数据,保证各个线程的数据不交叉:一是多个线程间如何共享数据,保证数据的一致性. 线程范围内共享数据 自己实现的话,是定义一个Map,线程为键,数据为值,表中的每一项即是为每个线程准备的数据,这样在一个线程中数据是一致的. 例子 package com.iot.thread; import java.util.HashMap; import java.util.Map; import java.util.Random; /*

  • java多线程并发中使用Lockers类将多线程共享资源锁定

    复制代码 代码如下: package com.yao; import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.Future;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReadWriteLock;import java.util.c

  • Java使用Thread和Runnable的线程实现方法比较

    本文实例讲述了Java使用Thread和Runnable的线程实现方法.分享给大家供大家参考,具体如下: 一 使用Thread实现多线程模拟铁路售票系统 1 代码 public class ThreadDemo { public static void main( String[] args ) { TestThread newTh = new TestThread( ); // 一个线程对象只能启动一次 newTh.start( ); newTh.start( ); newTh.start(

  • java通过共享变量结束run停止线程的方法示例

    stop()方法已经被弃用,原因是不太安全.API文档中给出了具体的详细解释.通过interrupted()方法打断线程.不推荐.通过共享变量结束run()方法,进而停止线程.如实例 复制代码 代码如下: public class ThreadInterrupt {    public static void main(String []args){        Runner run = new Runner();        run.start();        try {       

  • Java线程间共享实现方法详解

    一.synchronize对象锁和类锁 synchronize为多线程关键字是一种同步锁,它可以修饰以下几种对象: 代码块:被修饰的代码块被称为同步代码块,作用的范围是{}里面的代码,作用的对象是调用这个代码块的对象 方法:被修饰的方法称为同步方法,作用的范围是整个方法,作用的对象是调用这个方法的对象 类:作用的范围是synchronize后面括号里的部分,作用的对象是当前这个类 1.对象锁 下面由一个栗子引入: public class TestSynchronize { //加了对象锁的方法

  • Java线程三种命名方法详解

    这篇文章主要介绍了Java线程三种命名方法详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 1.实例化一个线程对象 Thread t = new Thread(); t.setName("甲"); 2.实例化一个线程对象的同时,通过构造方法对线程进行命名 Thread(Runnable r, String name) Thread t = new Thread(() -> {}, "甲"); 3.使用自定义

  • java并发编程_线程池的使用方法(详解)

    一.任务和执行策略之间的隐性耦合 Executor可以将任务的提交和任务的执行策略解耦 只有任务是同类型的且执行时间差别不大,才能发挥最大性能,否则,如将一些耗时长的任务和耗时短的任务放在一个线程池,除非线程池很大,否则会造成死锁等问题 1.线程饥饿死锁 类似于:将两个任务提交给一个单线程池,且两个任务之间相互依赖,一个任务等待另一个任务,则会发生死锁:表现为池不够 定义:某个任务必须等待池中其他任务的运行结果,有可能发生饥饿死锁 2.线程池大小 注意:线程池的大小还受其他的限制,如其他资源池:

  • Java并发编程之Exchanger方法详解

    简介 Exchanger是一个用于线程间数据交换的工具类,它提供一个公共点,在这个公共点,两个线程可以交换彼此的数据. 当一个线程调用exchange方法后将进入等待状态,直到另外一个线程调用exchange方法,双方完成数据交换后继续执行. Exchanger的使用 方法介绍 exchange(V x):阻塞当前线程,直到另外一个线程调用exchange方法或者当前线程被中断. x : 需要交换的对象. exchange(V x, long timeout, TimeUnit unit):阻塞

  • Java AtomicInteger类的使用方法详解

    首先看两段代码,一段是Integer的,一段是AtomicInteger的,为以下: public class Sample1 { private static Integer count = 0; synchronized public static void increment() { count++; } } 以下是AtomicInteger的: public class Sample2 { private static AtomicInteger count = new AtomicIn

  • Java线程的生命周期的详解

    Java线程的生命周期的详解 对于多线程编程而言,理解线程的生命周期非常重要,本文就针对这一点进行讲解. 一.线程的状态 线程的存在有几种不同的状态,如下: New状态 Ready状态 Running状态 Dead状态 Non Runnable状态 1.New状态 New状态是线程已经被创建,但是还未开始运行的状态.此状态通过调用线程的start()方法可让线程运行. 2.Runnable状态 Runnable状态可称为准备运行状态,也可称为队列,此状态通过调用线程的start()方法可让线程运

  • 基于java 线程的几种状态(详解)

    线程可以有六种状态: 1.New(新创建) 2.Runnable(可运行)(运行) 3.Blocked(被阻塞) 4.Waiting(等待) 5.Timed waiting(计时等待) 6.Terminated(被终止) 新创建线程: 当用new操作符创建一个新线程时,如new Thread(r),该线程还没有开始运行,它的当前状态为new,在线程运行之前还有一些基础工作要做. 可运行线程: 一旦线程调用start方法,线程处于runnable状态.在这个状态下的线程可能正在运行也可能没有运行(

  • Java线程池FutureTask实现原理详解

    前言 线程池可以并发执行多个任务,有些时候,我们可能想要跟踪任务的执行结果,甚至在一定时间内,如果任务没有执行完成,我们可能还想要取消任务的执行,为了支持这一特性,ThreadPoolExecutor提供了 FutureTask 用于追踪任务的执行和取消.本篇介绍FutureTask的实现原理. 类视图 为了更好的理解FutureTask的实现原理,这里先提供几个重要接口和类的结构,如下图所示: RunnableAdapter ThreadPoolExecutor提供了submit接口用于提交任

  • wxpython多线程防假死与线程间传递消息实例详解

    wxpython中启用线程的方法,将GUI和功能的执行分开. 网上关于python多线程防假死与线程传递消息是几年前的,这里由于wxpython和threading模块已经更新最新,因此给出最新修改代码,能在2017年最新版的python和模块中运行. 原来的publisher()和callafter都无法使用. 修改后的代码. import time import wx from threading import Thread from wx.lib.pubsub import pub cla

  • Java 线程的优先级(setPriority)案例详解

    线程可以划分优先级,优先级高的线程得到的CPU资源比较多,也就是CPU优先执行优先级高的线程对象中的任务. 设置线程优先级有助于帮助线程规划器确定下一次选中哪一个线程优先执行. java中优先级分为1-10个级别 线程优先级的继承特性 例如a线程启迪b线程,则b线程的优先级与a的一样. 代码说话:(很简单) public class MyThread1 extends Thread { @Override public void run() { System.out.println("MyThr

随机推荐