当前位置:首页 > Java技术文章 > java 多线程的同步几种方法

浅析java 多线程的同步

  • 发布时间:
  • 作者:码农之家原创
  • 点击:116

这篇文章主要知识点是关于java、多线程、多线程同步、java多线程之线程同步七种方式代码示例 的内容,如果大家想对相关知识点有系统深入的学习,可以参阅以下java相关资源

JavaScript ES6函数式编程入门经典

本书使用JavaScript ES6带你学习函数式编程。你将学习柯里化、偏函数、高阶函数以及Monad等概念。具有一定的参考价值,感兴趣的小伙伴们可以参考一下

查看详情

java 多线程的同步几种方法

java 多线程的同步几种方法

一、引言

前几天面试,被大师虐残了,好多基础知识必须得重新拿起来啊。闲话不多说,进入正题。

二、为什么要线程同步

因为当我们有多个线程要同时访问一个变量或对象时,如果这些线程中既有读又有写操作时,就会导致变量值或对象的状态出现混乱,从而导致程序异常。举个例子,如果一个银行账户同时被两个线程操作,一个取100块,一个存钱100块。假设账户原本有0块,如果取钱线程和存钱线程同时发生,会出现什么结果呢?取钱不成功,账户余额是100.取钱成功了,账户余额是0.那到底是哪个呢?很难说清楚。因此多线程同步就是要解决这个问题。

三、不同步时的代码

Bank.java

package threadTest; 

/** 
 * @author ww 
 * 
 */ 
public class Bank { 

  private int count =0;//账户余额 

  //存钱 
  public void addMoney(int money){ 
    count +=money; 
    System.out.println(System.currentTimeMillis()+"存进:"+money); 
  } 

  //取钱 
  public void subMoney(int money){ 
    if(count-money < 0){ 
      System.out.println("余额不足"); 
      return; 
    } 
    count -=money; 
    System.out.println(+System.currentTimeMillis()+"取出:"+money); 
  } 

  //查询 
  public void lookMoney(){ 
    System.out.println("账户余额:"+count); 
  } 
}

SyncThreadTest.java

package threadTest; 
/**
 * Java学习交流QQ群:589809992 我们一起学Java!
 */
public class SyncThreadTest { 

  public static void main(String args[]){ 
    final Bank bank=new Bank(); 

    Thread tadd=new Thread(new Runnable() { 

      @Override 
      public void run() { 
        // TODO Auto-generated method stub 
        while(true){ 
          try { 
            Thread.sleep(1000); 
          } catch (InterruptedException e) { 
            // TODO Auto-generated catch block 
            e.printStackTrace(); 
          } 
          bank.addMoney(100); 
          bank.lookMoney(); 
          System.out.println("\n"); 

        } 
      } 
    }); 

    Thread tsub = new Thread(new Runnable() { 

      @Override 
      public void run() { 
        // TODO Auto-generated method stub 
        while(true){ 
          bank.subMoney(100); 
          bank.lookMoney(); 
          System.out.println("\n"); 
          try { 
            Thread.sleep(1000); 
          } catch (InterruptedException e) { 
            // TODO Auto-generated catch block 
            e.printStackTrace(); 
          }   
        } 
      } 
    }); 
    tsub.start(); 

    tadd.start(); 
  } 

}

代码很简单,我就不解释了,看看运行结果怎样呢?截取了其中的一部分,是不是很乱,有写看不懂。

余额不足 
账户余额:0 

余额不足 
账户余额:100 

1441790503354存进:100 
账户余额:100 

1441790504354存进:100 
账户余额:100 

1441790504354取出:100 
账户余额:100 

1441790505355存进:100 
账户余额:100 

1441790505355取出:100 
账户余额:100

四、使用同步时的代码

(1)同步方法:

即有synchronized关键字修饰的方法。 由于java的每个对象都有一个内置锁,当用此关键字修饰方法时,内置锁会保护整个方法。在调用该方法前,需要获得内置锁,否则就处于阻塞状态。
修改后的Bank.java

package threadTest; 

/** 
 * @author ww 
 * 
 */ 
public class Bank { 

  private int count =0;//账户余额 

  //存钱 
  public synchronized void addMoney(int money){ 
    count +=money; 
    System.out.println(System.currentTimeMillis()+"存进:"+money); 
  } 

  //取钱 
  public synchronized void subMoney(int money){ 
    if(count-money < 0){ 
      System.out.println("余额不足"); 
      return; 
    } 
    count -=money; 
    System.out.println(+System.currentTimeMillis()+"取出:"+money); 
  } 

  //查询 
  public void lookMoney(){ 
    System.out.println("账户余额:"+count); 
  } 
}

再看看运行结果:

余额不足 
账户余额:0 

余额不足 
账户余额:0 

1441790837380存进:100 
账户余额:100 

1441790838380取出:100 
账户余额:0 
1441790838380存进:100 
账户余额:100 

1441790839381取出:100 
账户余额:0

瞬间感觉可以理解了吧。

注: synchronized关键字也可以修饰静态方法,此时如果调用该静态方法,将会锁住整个类

(2)同步代码块

即有synchronized关键字修饰的语句块。被该关键字修饰的语句块会自动被加上内置锁,从而实现同步
Bank.java代码如下:

package threadTest; 

/** 
 * @author ww 
 * 
 */ 
public class Bank { 

  private int count =0;//账户余额 

  //存钱 
  public  void addMoney(int money){ 

    synchronized (this) { 
      count +=money; 
    } 
    System.out.println(System.currentTimeMillis()+"存进:"+money); 
  } 

  //取钱 
  public  void subMoney(int money){ 

    synchronized (this) { 
      if(count-money < 0){ 
        System.out.println("余额不足"); 
        return; 
      } 
      count -=money; 
    } 
    System.out.println(+System.currentTimeMillis()+"取出:"+money); 
  } 

  //查询 
  public void lookMoney(){ 
    System.out.println("账户余额:"+count); 
  } 
}

运行结果如下:

余额不足 
账户余额:0 

1441791806699存进:100 
账户余额:100 

1441791806700取出:100 
账户余额:0 

1441791807699存进:100 
账户余额:100

效果和方法一差不多。

注:同步是一种高开销的操作,因此应该尽量减少同步的内容。通常没有必要同步整个方法,使用synchronized代码块同步关键代码即可。

(3)使用特殊域变量(Volatile)实现线程同步

a.volatile关键字为域变量的访问提供了一种免锁机制b.使用volatile修饰域相当于告诉虚拟机该域可能会被其他线程更新c.因此每次使用该域就要重新计算,而不是使用寄存器中的值d.volatile不会提供任何原子操作,它也不能用来修饰final类型的变量

Bank.java代码如下:

package threadTest; 

/** 
 * @author ww 
 * 
 */ 
public class Bank { 

  private volatile int count = 0;// 账户余额 

  // 存钱 
  public void addMoney(int money) { 

    count += money; 
    System.out.println(System.currentTimeMillis() + "存进:" + money); 
  } 

  // 取钱 
  public void subMoney(int money) { 

    if (count - money < 0) { 
      System.out.println("余额不足"); 
      return; 
    } 
    count -= money; 
    System.out.println(+System.currentTimeMillis() + "取出:" + money); 
  } 

  // 查询 
  public void lookMoney() { 
    System.out.println("账户余额:" + count); 
  } 
}

运行效果怎样呢?

余额不足 
账户余额:0 

余额不足 
账户余额:100 

1441792010959存进:100 
账户余额:100 

1441792011960取出:100 
账户余额:0 

1441792011961存进:100 
账户余额:100

是不是又看不懂了,又乱了。这是为什么呢?就是因为volatile不能保证原子操作导致的,因此volatile不能代替synchronized。此外volatile会组织编译器对代码优化,因此能不使用它就不适用它吧。它的原理是每次要线程要访问volatile修饰的变量时都是从内存中读取,而不是存缓存当中读取,因此每个线程访问到的变量值都是一样的。这样就保证了同步。

(4)使用重入锁实现线程同步

在JavaSE5.0中新增了一个java.util.concurrent包来支持同步。ReentrantLock类是可重入、互斥、实现了Lock接口的锁, 它与使用synchronized方法和快具有相同的基本行为和语义,并且扩展了其能力。ReenreantLock类的常用方法有:ReentrantLock() : 创建一个ReentrantLock实例lock() : 获得锁unlock() : 释放锁注:ReentrantLock()还有一个可以创建公平锁的构造方法,但由于能大幅度降低程序运行效率,不推荐使用Bank.java代码修改如下:

package threadTest; 

import java.util.concurrent.locks.Lock; 
import java.util.concurrent.locks.ReentrantLock; 

/** 
 * @author ww 
 * 
 */ 
public class Bank { 

  private int count = 0;// 账户余额 

  //需要声明这个锁 
  private Lock lock = new ReentrantLock(); 

  // 存钱 
  public void addMoney(int money) { 
    lock.lock();//上锁 
    try{ 
    count += money; 
    System.out.println(System.currentTimeMillis() + "存进:" + money); 

    }finally{ 
      lock.unlock();//解锁 
    } 
  } 

  // 取钱 
  public void subMoney(int money) { 
    lock.lock(); 
    try{ 

    if (count - money < 0) { 
      System.out.println("余额不足"); 
      return; 
    } 
    count -= money; 
    System.out.println(+System.currentTimeMillis() + "取出:" + money); 
    }finally{ 
      lock.unlock(); 
    } 
  } 

  // 查询 
  public void lookMoney() { 
    System.out.println("账户余额:" + count); 
  } 
}

运行效果怎么样呢?

余额不足 
账户余额:0 

余额不足 
账户余额:0 

1441792891934存进:100 
账户余额:100 

1441792892935存进:100 
账户余额:200 

1441792892954取出:100 
账户余额:100

效果和前两种方法差不多。

如果synchronized关键字能满足用户的需求,就用synchronized,因为它能简化代码 。如果需要更高级的功能,就用ReentrantLock类,此时要注意及时释放锁,否则会出现死锁,通常在finally代码释放锁

(5)使用局部变量实现线程同步

Bank.java代码如下:

package threadTest; 

/** 
 * @author ww 
 * 
 */ 
public class Bank { 

  private static ThreadLocal<Integer> count = new ThreadLocal<Integer>(){ 

    @Override 
    protected Integer initialValue() { 
      // TODO Auto-generated method stub 
      return 0; 
    } 

  }; 

  // 存钱 
  public void addMoney(int money) { 
    count.set(count.get()+money); 
    System.out.println(System.currentTimeMillis() + "存进:" + money); 

  } 

  // 取钱 
  public void subMoney(int money) { 
    if (count.get() - money < 0) { 
      System.out.println("余额不足"); 
      return; 
    } 
    count.set(count.get()- money); 
    System.out.println(+System.currentTimeMillis() + "取出:" + money); 
  } 

  // 查询 
  public void lookMoney() { 
    System.out.println("账户余额:" + count.get()); 
  } 
}

运行效果:

余额不足 
账户余额:0 

余额不足 
账户余额:0 

1441794247939存进:100 
账户余额:100 

余额不足 
1441794248940存进:100 
账户余额:0 

账户余额:200 

余额不足 
账户余额:0 

1441794249941存进:100 
账户余额:300

看了运行效果,一开始一头雾水,怎么只让存,不让取啊?看看ThreadLocal 的原理:

如果使用ThreadLocal管理变量,则每一个使用该变量的线程都获得该变量的副本,副本之间相互独立,这样每一个线程都可以随意修改自己的变量副本,而不会对其他线程产生影响。现在明白了吧,原来每个线程运行的都是一个副本,也就是说存钱和取钱是两个账户,知识名字相同而已。所以就会发生上面的效果。

ThreadLocal与同步机制

a.ThreadLocal与同步机制都是为了解决多线程中相同变量的访问冲突问题b.前者采用以”空间换时间”的方法,后者采用以”时间换空间”的方式

如有疑问请留言或者到本站社区交流讨论,感谢阅读,希望能帮助到大家,谢谢大家对本站的支持!

java多线程之线程同步七种方式代码示例

为何要使用同步? 

    java允许多线程并发控制,当多个线程同时操作一个可共享的资源变量时(如数据的增删改查),
    将会导致数据不准确,相互之间产生冲突,因此加入同步锁以避免在该线程没有完成操作之前,被其他线程的调用,
    从而保证了该变量的唯一性和准确性。

1.同步方法 

    即有synchronized关键字修饰的方法。
    由于java的每个对象都有一个内置锁,当用此关键字修饰方法时,
    内置锁会保护整个方法。在调用该方法前,需要获得内置锁,否则就处于阻塞状态。
    代码如: 
    public synchronized void save(){}

   注: synchronized关键字也可以修饰静态方法,此时如果调用该静态方法,将会锁住整个类

2.同步代码块 

    即有synchronized关键字修饰的语句块。
    被该关键字修饰的语句块会自动被加上内置锁,从而实现同步
    代码如: 
    synchronized(object){ }

    注:同步是一种高开销的操作,因此应该尽量减少同步的内容。 

    通常没有必要同步整个方法,使用synchronized代码块同步关键代码即可。 

    代码实例:

package com.xhj.thread;
  /**
   * 线程同步的运用
   * 
   * @author XIEHEJUN
   * 
   */
  public class SynchronizedThread {
    class Bank {
      private int account = 100;
      public int getAccount() {
        return account;
      }
      /**
       * 用同步方法实现
       * 
       * @param money
       */
      public synchronized void save(int money) {
        account += money;
      }
      /**
       * 用同步代码块实现
       * 
       * @param money
       */
      public void save1(int money) {
        synchronized (this) {
          account += money;
        }
      }
    }
    class NewThread implements Runnable {
      private Bank bank;
      public NewThread(Bank bank) {
        this.bank = bank;
      }
      @Override
      public void run() {
        for (int i = 0; i < 10; i++) {
          // bank.save1(10);
          bank.save(10);
          System.out.println(i + "账户余额为:" + bank.getAccount());
        }
      }
    }
    /**
     * 建立线程,调用内部类
     */
    public void useThread() {
      Bank bank = new Bank();
      NewThread new_thread = new NewThread(bank);
      System.out.println("线程1");
      Thread thread1 = new Thread(new_thread);
      thread1.start();
      System.out.println("线程2");
      Thread thread2 = new Thread(new_thread);
      thread2.start();
    }
    public static void main(String[] args) {
      SynchronizedThread st = new SynchronizedThread();
      st.useThread();
    }
  }

3.使用特殊域变量(volatile)实现线程同步

    a.volatile关键字为域变量的访问提供了一种免锁机制,
    b.使用volatile修饰域相当于告诉虚拟机该域可能会被其他线程更新,
    c.因此每次使用该域就要重新计算,而不是使用寄存器中的值
    d.volatile不会提供任何原子操作,它也不能用来修饰final类型的变量 

    例如: 

        在上面的例子当中,只需在account前面加上volatile修饰,即可实现线程同步。 

    代码实例:

//只给出要修改的代码,其余代码与上同
    class Bank {
      //需要同步的变量加上volatile
      private volatile int account = 100;

      public int getAccount() {
        return account;
      }
      //这里不再需要synchronized 
      public void save(int money) {
        account += money;
      }
    }

    注:多线程中的非同步问题主要出现在对域的读写上,如果让域自身避免这个问题,则就不需要修改操作该域的方法。 

    用final域,有锁保护的域和volatile域可以避免非同步的问题。

4.使用重入锁实现线程同步

    在JavaSE5.0中新增了一个java.util.concurrent包来支持同步。
    ReentrantLock类是可重入、互斥、实现了Lock接口的锁,
    它与使用synchronized方法和快具有相同的基本行为和语义,并且扩展了其能力
    ReenreantLock类的常用方法有:
        ReentrantLock() : 创建一个ReentrantLock实例
        lock() : 获得锁
        unlock() : 释放锁 

    注:ReentrantLock()还有一个可以创建公平锁的构造方法,但由于能大幅度降低程序运行效率,不推荐使用 

    例如: 

        在上面例子的基础上,改写后的代码为: 

    代码实例:

//只给出要修改的代码,其余代码与上同
    class Bank {
      
      private int account = 100;
      //需要声明这个锁
      private Lock lock = new ReentrantLock();
      public int getAccount() {
        return account;
      }
      //这里不再需要synchronized 
      public void save(int money) {
        lock.lock();
        try{
          account += money;
        }finally{
          lock.unlock();
        }
        
      }
    }

    注:关于Lock对象和synchronized关键字的选择: 

        a.最好两个都不用,使用一种java.util.concurrent包提供的机制, 
           能够帮助用户处理所有与锁相关的代码。 
        b.如果synchronized关键字能满足用户的需求,就用synchronized,因为它能简化代码
        c.如果需要更高级的功能,就用ReentrantLock类,此时要注意及时释放锁,否则会出现死锁,通常在finally代码释放锁

5.使用局部变量实现线程同步 

    如果使用ThreadLocal管理变量,则每一个使用该变量的线程都获得该变量的副本,  副本之间相互独立,这样每一个线程都可以随意修改自己的变量副本,而不会对其他线程产生影响。

    ThreadLocal 类的常用方法
    ThreadLocal() : 创建一个线程本地变量
    get() : 返回此线程局部变量的当前线程副本中的值
    initialValue() : 返回此线程局部变量的当前线程的"初始值"
    set(T value) : 将此线程局部变量的当前线程副本中的值设置为value

    例如: 

        在上面例子基础上,修改后的代码为: 

    代码实例:

//只改Bank类,其余代码与上同
    public class Bank{
      //使用ThreadLocal类管理共享变量account
      private static ThreadLocal<Integer> account = new ThreadLocal<Integer>(){
        @Override
        protected Integer initialValue(){
          return 100;
        }
      };
      public void save(int money){
        account.set(account.get()+money);
      }
      public int getAccount(){
        return account.get();
      }
    }

   注:ThreadLocal与同步机制 

        a.ThreadLocal与同步机制都是为了解决多线程中相同变量的访问冲突问题。
        b.前者采用以"空间换时间"的方法,后者采用以"时间换空间"的方式

6.使用阻塞队列实现线程同步

    前面5种同步方式都是在底层实现的线程同步,但是我们在实际开发当中,应当尽量远离底层结构。
    使用javaSE5.0版本中新增的java.util.concurrent包将有助于简化开发。
    本小节主要是使用LinkedBlockingQueue<E>来实现线程的同步
    LinkedBlockingQueue<E>是一个基于已连接节点的,范围任意的blocking queue。
    队列是先进先出的顺序(FIFO),关于队列以后会详细讲解~ 

   LinkedBlockingQueue 类常用方法 

    LinkedBlockingQueue() : 创建一个容量为Integer.MAX_VALUE的LinkedBlockingQueue
    put(E e) : 在队尾添加一个元素,如果队列满则阻塞
    size() : 返回队列中的元素个数
    take() : 移除并返回队头元素,如果队列空则阻塞 

  代码实例: 

实现商家生产商品和买卖商品的同步

package com.xhj.thread;
import java.util.Random;
import java.util.concurrent.LinkedBlockingQueue;
/**
 * 用阻塞队列实现线程同步 LinkedBlockingQueue的使用
 * 
 * @author XIEHEJUN
 * 
 */
public class BlockingSynchronizedThread {
  /**
   * 定义一个阻塞队列用来存储生产出来的商品
   */
  private LinkedBlockingQueue<Integer> queue = new LinkedBlockingQueue<Integer>();
  /**
   * 定义生产商品个数
   */
  private static final int size = 10;
  /**
   * 定义启动线程的标志,为0时,启动生产商品的线程;为1时,启动消费商品的线程
   */
  private int flag = 0;
  private class LinkBlockThread implements Runnable {
    @Override
    public void run() {
      int new_flag = flag++;
      System.out.println("启动线程 " + new_flag);
      if (new_flag == 0) {
        for (int i = 0; i < size; i++) {
          int b = new Random().nextInt(255);
          System.out.println("生产商品:" + b + "号");
          try {
            queue.put(b);
          } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
          }
          System.out.println("仓库中还有商品:" + queue.size() + "个");
          try {
            Thread.sleep(100);
          } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
          }
        }
      } else {
        for (int i = 0; i < size / 2; i++) {
          try {
            int n = queue.take();
            System.out.println("消费者买去了" + n + "号商品");
          } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
          }
          System.out.println("仓库中还有商品:" + queue.size() + "个");
          try {
            Thread.sleep(100);
          } catch (Exception e) {
            // TODO: handle exception
          }
        }
      }
    }
  }
  public static void main(String[] args) {
    BlockingSynchronizedThread bst = new BlockingSynchronizedThread();
    LinkBlockThread lbt = bst.new LinkBlockThread();
    Thread thread1 = new Thread(lbt);
    Thread thread2 = new Thread(lbt);
    thread1.start();
    thread2.start();
  }
}

注:BlockingQueue<E>定义了阻塞队列的常用方法,尤其是三种添加元素的方法,我们要多加注意,当队列满时:

  add()方法会抛出异常
  offer()方法返回false
  put()方法会阻塞

7.使用原子变量实现线程同步

需要使用线程同步的根本原因在于对普通变量的操作不是原子的。

那么什么是原子操作呢?
原子操作就是指将读取变量值、修改变量值、保存变量值看成一个整体来操作
即-这几种行为要么同时完成,要么都不完成。

在java的util.concurrent.atomic包中提供了创建了原子类型变量的工具类,使用该类可以简化线程同步。
其中AtomicInteger 表可以用原子方式更新int的值,可用在应用程序中(如以原子方式增加的计数器),
但不能用于替换Integer;可扩展Number,允许那些处理机遇数字类的工具和实用工具进行统一访问。

AtomicInteger类常用方法:

AtomicInteger(int initialValue) : 创建具有给定初始值的新的AtomicInteger
addAddGet(int dalta) : 以原子方式将给定值与当前值相加
get() : 获取当前值

代码实例:

只改Bank类,其余代码与上面第一个例子同

class Bank {
    private AtomicInteger account = new AtomicInteger(100);
    public AtomicInteger getAccount() {
      return account;
    }
    public void save(int money) {
      account.addAndGet(money);
    }
  }

补充--原子操作主要有:

  对于引用变量和大多数原始变量(long和double除外)的读写操作;
  对于所有使用volatile修饰的变量(包括long和double)的读写操作。

代码的世界里,你就是上帝。

总结

以上就是本文关于java多线程之线程同步七种方式代码示例的全部内容,希望对大家有所帮助。感兴趣的朋友可以继续参阅本站:Java多线程饥饿与公平介绍及代码示例、Java编程之多线程死锁与线程间通信简单实现代码、Java多线程阻塞与唤醒代码示例等,有什么问题可以随时留言,小编会及时回复大家的。感谢朋友们对本站的支持!

以上就是本次给大家分享的关于Java的全部知识点内容总结,大家还可以在下方相关文章里找到关于Java I/O 模型的原理知、 java实现统计字符串中大小、 java线程池使用后是否需要、 等java文章进一步学习,感谢大家的阅读和支持。

上一篇:Spring Boot报错:No session repository could be auto-configured, check your configuration如何解决

下一篇:spring boot集成rabbitmq的代码实例

展开 +

收起 -

java多线程同步 相关内容
【java 多线程】守护线程与非守护线程示例效果

这篇文章主要介绍了java守护线程与非守护线程,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧

查看详情
Three.js开发指南:WebGL的JavaScript 3D库 查看详情
同构JavaScript应用开发 查看详情
Java EE框架整合开发入门到实战

初学者新手入门,重视实战演练教学视频,全线视频语音解读教育资源丰富 这书详细解读了JavaEE中Spring、SpringMVC和MyBatis三大框架(SSM)的基本知识和实际应用。为了方便帮助用户学习SSM框架,

查看详情
OpenCV3.0 Computer Vision with Java

本文档是OpenCV 3.0 Computer Vision with Java的中文翻译版,如果你是Java开发者、学生、研究者或爱好者,想要在Java中创建计算机视觉应用,那么这本书是为你准备的,感兴趣的就下载来了解一下吧

查看详情
Java学习指南

《Java学习指南(第4版)(上、下册)》 是畅销Java学习指南的最新版,详细介绍了Java 6和Java 7的语言特性和API。本书全面介绍了Java的基础知识,力图通过完备地介绍Java语言、其类库、编程技术以及

查看详情
Java从小白到大牛

Java从小白到大牛是一本Java语言学习教程,读者群是零基础小白,通过本书的学习能够成为Java大牛。主要内容包括:Java语法基础、数据类型、运算符、控制语句、数组、字符串、面向对象基础、继承与多态、抽象类与接口、集合框架、异常处理、输入输出和网络编程等技术。

查看详情
Java并发编程的艺术 查看详情
java多线程同步 学习笔记
网友NO.604155

Java多线程中不同条件下编写生产消费者模型方法介绍

简介: 生产者、消费者模型是多线程编程的常见问题,最简单的一个生产者、一个消费者线程模型大多数人都能够写出来,但是一旦条件发生变化,我们就很容易掉进多线程的bug中。这篇文章主要讲解了生产者和消费者的数量,商品缓存位置数量,商品数量等多个条件的不同组合下,写出正确的生产者消费者模型的方法。 欢迎探讨,如有错误敬请指正 生产消费者模型 生产者消费者模型具体来讲,就是在一个系统中,存在生产者和消费者两种角色,他们通过内存缓冲区进行通信,生产者生产消费者需要的资料,消费者把资料做成产品。生产消费者模式如下图。 定义商品类 package demo;/*定义商品*/public class Goods {public final String name;public final int price;public final int id;public Goods(String name, int price, int id){this.name = name;/*类型*/this.price = price;/*价格*/this.id = id;/*商品……

网友NO.625708

Java多线程之Callable接口的实现

1.接口的定义: public interface CallableV { V call() throws Exception; } 2.Callable和Runnable的异同 先看下Runnable接口的定义 public interface Runnable { public abstract void run();} Callable的call()方法类似于Runnable接口中run()方法,都定义任务要完成的工作,实现这两个接口时要分别重写这两个方法,主要的不同之处是call()方法是有返回值的(其实还有一些区别,例如call方法可以抛出异常,run方法不可以),运行Callable任务可以拿到一个Future对象,表示异步计算的结果。它提供了检查计算是否完成的方法,以等待计算的完成,并检索计算的结果。通过Future对象可以了解任务执行情况,可取消任务的执行,还可获取执行结果。 3. Callable类型的任务可以有两种执行方式: 我们先定义一个Callable任务MyCallableTask: class MyCallableTask implements CallableInteger{ @Override public Integer call() throws Exception { ……

网友NO.334259

JavaScript多线程运行库Nexus.js详解

首先,如果你不熟悉这个项目,建议先阅读之前写的一系列文章。如果你不想阅读这些,不用担心。这里面也会涉及到那些内容。 现在,让我们开始吧。 去年,我开始实现Nexus.js,这是一个基于Webkit/JavaScript内核的多线程服务端JavaScript运行库。有一段时间我放弃了做这件事,由于一些我无法控制的原因,我不打算在这里讨论,主要是:我无法让自己长时间工作。 所以,让我们从讨论Nexus的架构开始,以及它是如何工作的。 事件循环 没有事件循环 有一个带有(无锁)任务对象的线程池 每次调用setTimeout或setImmediate或创建一个Promise时,任务就排队到任务队列钟。 每当计划任务时,第一个可用的线程将选择任务并执行它。 在CPU内核上处理Promise。对Promise.all()的调用将并行的解决Promise。 ES6 支持async/await,并且推荐使用 支持for await(...) 支持解构 支持asyn……

网友NO.292645

java虚拟机多线程进阶篇总结

1.线程池基本参数 以Executors.newFixedThreadPool()这种创建方式为例: 大家想象,假如你创建一个线程池,你想这个池子有些什么参数呢?首先这个池子必须要有一个最大值;然后还希望这个池子的线程数量有一个警戒线,到了这个警戒线的位置说明线程池暂时已经满了,如果这个时候还有人过来拿线程,我们就要把这些人抓起来扔到一个地方去让他们排队,告诉他们:请稍等,等我们的线程有空闲的时候再来处理你的事;再然后假如人排队的地方都满了,玛德,好多人,于是线程池就想办法东拼西凑又多搞出来了几个线程去处理了;最后,假如那搞出来的这几个线程还是不够用,并且排队的地方总是满的,于是线程池生气了,就这么多人可以了,如果还有人过来的赶紧让它滚蛋; 这里我们需要知道几个东西: 1这里的警戒线叫做核心线程池大小(core……

网友NO.832003

Java多线程ThreadAPI详细介绍

1.Thread的构造方法 package threadAPI; public class CreateThread { public static void main(String[] args) { Thread t1 = new Thread(); Thread t2 = new Thread(); t1.start(); t2.start(); System.out.println(t1.getName()); System.out.println(t2.getName()); }} 总结1: 创建线程对象Thread,默认有一个线程名,以Thread-开头,从0开始计数 Thread-0 Thread-1 Thread-2 可以看到Thread()中默认传入的第二个参数,即Runnable接口为null 在init方法中, 会将我们传入的target给Thread的成员变量 然后在调用run方法的时候,会做如下判断 所以当target为null的时候,默认的run方法中什么也不做 总结2: 如果在构造Thread的时候,没有传递Runnable接口或者没有复写Thread的run方法,该Thread将不会调用任何东西 如果传递了Runnable接口的实例,则会执行该方法的逻辑代码 如果复写了Thread的run方法,则会执行复写的逻辑代码 为线程传递一个线程名 这时我们……

<
1
>

Copyright 2018-2020 xz577.com 码农之家

本站所有电子书资源不再提供下载地址,只分享来路

免责声明:网站所有作品均由会员网上搜集共同更新,仅供读者预览及学习交流使用,下载后请24小时内删除

版权投诉 / 书籍推广 / 赞助:QQ:520161757