Java中怎么实现线程间共享

这篇文章给大家介绍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@6b52350csyn ended...com.zl.synchronize.TestSynchronize@6b52350csyn is going...com.zl.synchronize.TestSynchronize@6b52350csyn ended...com.zl.synchronize.TestSynchronize@6b52350c*//**当一个传入testSynchronize，另一个传入testSynchronize2时 运行结果如下：thread is running...thread2 is running...syn is going...com.zl.synchronize.TestSynchronize@28835f5fsyn is going...com.zl.synchronize.TestSynchronize@47c48106syn ended...com.zl.synchronize.TestSynchronize@28835f5fsyn 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 number = new ThreadLocal(){    @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====13Thread-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 object1571039516251:T2 start! notify one thread1571039521251:T2 end! 1571039521251:T1 end! */

五、等待超时模式

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

伪代码如下所示：

//假设超时时间是mills，则等待持续时间是remaining,超时时间是futurelong 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()+"---执行完毕");  }}/**15710611680641571061170065main---执行完毕Thread-0---执行完毕！Thread-1---执行完毕！Thread-2---执行完毕！Thread-3---执行完毕！Thread-4---执行完毕！*/

关于Java中怎么实现线程间共享就分享到这里了，希望以上内容可以对大家有一定的帮助，可以学到更多知识。如果觉得文章不错，可以把它分享出去让更多的人看到。