java是什么（java是什么意思）

精选文章1

20小时52分钟前整理

java 中的instanceof用法详解及instanceof是什么意思(推荐)

好，应大家的要求先给大家说下在JAVA程序中instanceof是什么意思

instanceof是Java的一个二元操作符，和==，>，<是同一类东东。由于它是由字母组成的，所以也是Java的保留关键字。它的作用是测试它左边的对象是否是它右边的类的实例，返回boolean类型的数据。

instanceof运算符用法

运算符是双目运算符,左面的操作元是一个对象实例,右面是一个类.当左面的对象是右面的类创建的对象时,该运算符运算的结果是true,否则是false

说明:

　　(1).一个类的实例包括本身的实例,以及所有直接或间接子类的实例

　　(2).instanceof左边操作元显式声明的类型与右边操作元必须是同种类或有继承关系,

　　　　即位于继承树的同一个分支上,否则会编译出错     

 double obj=1;
 if(obj instanceof Double){
 System.out.println("true");
 }

　　报 "Incompatible conditional operand types double and Double" 错误

      obj 必须是对象的实例。不能是基础数据类型。　

　 String obj=1.0+"";
 if(obj instanceof Double){
 System.out.println("true");
 }

       报 "Incompatible conditional operand types String and Double" 错误

　　 String 和 Double 不是位于继承树的同一个分支上。　　

　if(null instanceof Object){
 System.out.println("true");
 }else{
 System.out.println("false");
 }
 String obj=null;
 if(obj instanceof Object){
 System.out.println("true");
 }else{
 System.out.println("false");
 }

      打印都为 false.  null用操作符instanceof测试任何类型时都是返回false的。

　if(obj instanceof null){
 System.out.println("true");
 }else{
 System.out.println("false");
 }

编译出错。报"Syntax error on token "null", invalid ReferenceType" 错误。

public class Test {
 public static void main(String[] args){
 System.out.println(new Student() instanceof String); //compile time error
 System.out.println(new Student() instanceof Exception); //compile time error
 System.out.println(new Student() instanceof Object); //compilation and output true
 System.out.println(new Student() instanceof List); //compilation and output false
 System.out.println(new Student() instanceof List<?>); //compilation and output false
 System.out.println(new Student() instanceof List<String>); //compile time error
 System.out.println(new Student() instanceof List<Object>); //compile time error
 System.out.println(new String() instanceof List); //compile time error
 System.out.println(new String() instanceof List<?>); //compile time error
 System.out.println(null instanceof Object); //compilation and output false 
 
 }
}
class Student{ 
}

　　　看到上面的测试结果可能会有这样那样的疑惑，为什么Student对象测试String的时候是编译错误，而测试List的时候又能够通过（难道是instanceof对接口在编译时不作检查呢，还是由于List类型本身在编译时不确定具体类型导致的），但是后面你又会发现如果是List<String>的时候编译就不通过了（看来前面的猜测是错误的，他对接口是要做检查的），可是往后面看，你又会纳闷String测试List还是List<?>的时候，直接在编译期就报错了，这跟Student对象测试List和List<?>的结果大不同，可能此时你有点相当不解了。我们这个时候翻看java对instanceof操作符的说明时，发现instanceof的这些表现都是跟cast操作符是有点关系的，就是说当我们在instanceof方法时，编译器会检查这个对象能够cast到右边的类型，如果不能cast则直接报错，如果不能确定类型，则通过编译，具体看运行时定。

　　这里可能还有一个疑惑，我们Student已经确定类型了啊，List类型也是确定的啊，为什么能够编译通过呢，而String却不行呢（难道是自己定义的类和系统定义的类在编译处理上有不同），这里java没有做特别的说明，但是我想可能是因为final关键字的区别造成的，我们发现不论String、Integer、Long等都是最终类，他们的处理类似于编译器对常量的处理，因为编译器知道这个类在运行期间是不会有改变的，故而编译器在编译期间认为他自己能够确定这个类的最终类型。而对于自己定义的类呢（我试过系统的非最终类Hashtable、HashMap等，测试和我们自定义的类的结果一样，可以通过编译），由于不是最终类，可能编译器认为他可能在运行期间会有改变的可能，故而不把他作最为确定的类型处理，故而可以通过编译。其实当我们在自定义的类前面加上final关键字的时候，其表现就跟String、Integer、Long这些最终类测试instanceof表现的一样了。

好，下面通过实例代码看下java中instanceof用法

java 中的instanceof 运算符是用来在运行时指出对象是否是特定类的一个实例。instanceof通过返回一个布尔值来指出，这个对象是否是这个特定类或者是它的子类的一个实例。

 用法：

result = object instanceof class

参数：

Result：布尔类型。
Object：必选项。任意对象表达式。
Class：必选项。任意已定义的对象类。

说明：

如果 object 是 class 的一个实例，则 instanceof 运算符返回 true。如果 object 不是指定类的一个实例，或者 object 是 null，则返回 false。

示例代码如下：

package com.instanceoftest;
 interface A{}
 class B implements A{
 }
 class C extends B {
 }
 class instanceoftest {
 public static void main(String[] args){
 A a=null;
 B b=null;
 boolean res; 
 System.out.println("instanceoftest test case 1: ------------------");
 res = a instanceof A; 
 System.out.println("a instanceof A: " + res);
 res = b instanceof B;
 System.out.println("b instanceof B: " + res);
 System.out.println("/ninstanceoftest test case 2: ------------------"); 
 a=new B();
 b=new B();
 res = a instanceof A; 
 System.out.println("a instanceof A: " + res);
 res = a instanceof B;
 System.out.println("a instanceof B: " + res);
 res = b instanceof A;
 System.out.println("b instanceof A: " + res);
 res = b instanceof B;
 System.out.println("b instanceof B: " + res);
 System.out.println("/ninstanceoftest test case 3: ------------------");
 B b2=(C)new C();
 res = b2 instanceof A;
 System.out.println("b2 instanceof A: " + res);
 res = b2 instanceof B;
 System.out.println("b2 instanceof B: " + res);
 res = b2 instanceof C;
 System.out.println("b2 instanceof C: " + res);
 }
}
/*
result:
instanceoftest test case 1: ------------------
a instanceof A: false
b instanceof B: false
instanceoftest test case 2: ------------------
a instanceof A: true
a instanceof B: true
b instanceof A: true
b instanceof B: true
instanceoftest test case 3: ------------------
b2 instanceof A: true
b2 instanceof B: true
b2 instanceof C: true
*/

总结

以上所述是小编给大家介绍的java 中的instanceof用法详解及instanceof是什么意思，希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对码农之家网站的支持！

精选文章2 Java 线程死锁

19小时22分钟前整理

Java中的线程死锁是什么？如何避免？

认识线程死锁

多个线程同时被阻塞，它们中的一个或者全部都在等待某个资源被释放。由于线程被无限期地阻塞，因此程序不可能正常终止。

如下图所示，线程 A 持有资源 2，线程 B 持有资源 1，他们同时都想申请对方的资源，所以这两个线程就会互相等待而进入死锁状态。

下面通过一个例子来说明线程死锁,代码模拟了上图的死锁的情况 (代码来源于《并发编程之美》)：

public class DeadLockDemo {
 private static Object resource1 = new Object();//资源 1
 private static Object resource2 = new Object();//资源 2

 public static void main(String[] args) {
  new Thread(() -> {
   synchronized (resource1) {
    System.out.println(Thread.currentThread() + "get resource1");
    try {
     Thread.sleep(1000);
    } catch (InterruptedException e) {
     e.printStackTrace();
    }
    System.out.println(Thread.currentThread() + "waiting get resource2");
    synchronized (resource2) {
     System.out.println(Thread.currentThread() + "get resource2");
    }
   }
  }, "线程 1").start();

  new Thread(() -> {
   synchronized (resource2) {
    System.out.println(Thread.currentThread() + "get resource2");
    try {
     Thread.sleep(1000);
    } catch (InterruptedException e) {
     e.printStackTrace();
    }
    System.out.println(Thread.currentThread() + "waiting get resource1");
    synchronized (resource1) {
     System.out.println(Thread.currentThread() + "get resource1");
    }
   }
  }, "线程 2").start();
 }
}

Output

Thread[线程 1,5,main]get resource1
Thread[线程 2,5,main]get resource2
Thread[线程 1,5,main]waiting get resource2
Thread[线程 2,5,main]waiting get resource1

线程 A 通过 synchronized (resource1) 获得 resource1 的监视器锁，然后通过Thread.sleep(1000);让线程 A 休眠 1s 为的是让线程 B 得到执行然后获取到 resource2 的监视器锁。线程 A 和线程 B 休眠结束了都开始企图请求获取对方的资源，然后这两个线程就会陷入互相等待的状态，这也就产生了死锁。上面的例子符合产生死锁的四个必要条件。

学过操作系统的朋友都知道产生死锁必须具备以下四个条件：

1. 互斥条件：该资源任意一个时刻只由一个线程占用。
2. 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
3. 不剥夺条件:线程已获得的资源在末使用完之前不能被其他线程强行剥夺，只有自己使用完毕后才释放资源。
4. 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。
   

如何避免线程死锁?

我们只要破坏产生死锁的四个条件中的其中一个就可以了。

• 破坏互斥条件

这个条件我们没有办法破坏，因为我们用锁本来就是想让他们互斥的（临界资源需要互斥访问）。

• 破坏请求与保持条件

一次性申请所有的资源。

• 破坏不剥夺条件

占用部分资源的线程进一步申请其他资源时，如果申请不到，可以主动释放它占有的资源。

• 破坏循环等待条件

靠按序申请资源来预防。按某一顺序申请资源，释放资源则反序释放。破坏循环等待条件。

我们对线程 2 的代码修改成下面这样就不会产生死锁了。

new Thread(() -> {
   synchronized (resource1) {
    System.out.println(Thread.currentThread() + "get resource1");
    try {
     Thread.sleep(1000);
    } catch (InterruptedException e) {
     e.printStackTrace();
    }
    System.out.println(Thread.currentThread() + "waiting get resource2");
    synchronized (resource2) {
     System.out.println(Thread.currentThread() + "get resource2");
    }
   }
  }, "线程 2").start();

Output

Thread[线程 1,5,main]get resource1
Thread[线程 1,5,main]waiting get resource2
Thread[线程 1,5,main]get resource2
Thread[线程 2,5,main]get resource1
Thread[线程 2,5,main]waiting get resource2
Thread[线程 2,5,main]get resource2

Process finished with exit code 0

我们分析一下上面的代码为什么避免了死锁的发生?

线程 1 首先获得到 resource1 的监视器锁,这时候线程 2 就获取不到了。然后线程 1 再去获取 resource2 的监视器锁，可以获取到。然后线程 1 释放了对 resource1、resource2 的监视器锁的占用，线程 2 获取到就可以执行了。这样就破坏了破坏循环等待条件，因此避免了死锁。

以上就是Java中的线程死锁是什么？如何避免？的详细内容，更多关于Java 线程死锁的资料请关注码农之家其它相关文章！

精选文章3 Java 弱引用

12小时50分钟前整理

Java 中的弱引用是什么

Java里一个对象obj被创建时，被放在堆里。当GC运行的时候，发现没有任何引用指向obj，那么就会回收obj对象的堆内存空间。

换句话说，一个对象被回收, 必须满足两个条件:

（1）没有任何引用指向它

（2）GC被运行。

在实际开发中，我们可以通过把所有指向某个对象的referece置空来保证这个对象在下次GC运行的时候被回收，类似下面：

Object c = new Car();  
c=null;

但是，这样做是一件很繁琐并且违背GC自动回收原则的事。对于简单的情况, 手动置空是不需要程序员来做的, 因为在java中, 对于简单对象, 当调用它的方法执行完毕后, 指向它的引用会被从栈中弹出, 所以它就能在下一次GC执行时被回收了。

但是, 也有特殊例外. 当使用cache的时候, 由于cache的对象正是程序运行需要的, 那么只要程序正在运行, cache中的引用就不会被GC(或者说, cache中的reference拥有了和主程序一样的life cycle). 那么随着cache中的reference越来越多, GC无法回收的object也越来越多, 无法被自动回收。当这些object需要被回收时, 回收这些object的任务只有交给程序编写者了。然而这却违背了GC的本质(自动回收可以回收的objects)。

所以, java中引入了weak reference。

Object c = new Car(); //只要c还指向car object, car object就不会被回收 -->（强引用）

当一个对象仅仅被weak reference指向, 而没有任何其他strong reference指向的时候, 如果GC运行, 那么这个对象就会被回收。

下面这个是网上的例子，首先定义一个实体类：

public class Car {
  private double   price;
  private String  color;

  public Car(double price, String color)
  {
    this.price = price;
    this.color = color;
  }

  public double getPrice()
  {
    return price;
  }

  public String getColor()
  {
    return color;
  }

  public String toString()
  {
    return "This car is a " + this.color + " car, costs $" + price;
  }
}

一般使用WeakReference的时候都会定义一个类继承自WeakReference，在这个类中再定义一些别的属性，这里就不定义别的属性了：

public class WeakReferenceCar extends WeakReference<Car>
{
  public WeakReferenceCar(Car car)
  {
    super(car);
  }
}

main函数调用一下，当然为了更清楚地看到GC的效果，设置虚拟机参数”-XX:+PrintGCDetails”：

public static void main(String[] args)
{
  Car car = new Car(2000.0, "red");
  WeakReferenceCar wrc = new WeakReferenceCar(car);
  wrc.setStr("111");
  int i = 0;
  while (true)
  {
    if (wrc.get() != null)
    {
      i++;
      System.out.println("WeakReferenceCar's Car is alive for " + i + ", loop - " + wrc);
    }
    else
    {
      System.out.println("WeakReferenceCar's Car has bean collected");
      break;
    }
  }
}

最后是运行结果

WeakReferenceCar's Car is alive for 68450, loop - interview.WeakReferenceCar@776ec8df
WeakReferenceCar's Car is alive for 68451, loop - interview.WeakReferenceCar@776ec8df
WeakReferenceCar's Car is alive for 68452, loop - interview.WeakReferenceCar@776ec8df
WeakReferenceCar's Car is alive for 68453, loop - interview.WeakReferenceCar@776ec8df
[GC (Allocation Failure) [PSYoungGen: 34304K->1000K(38400K)] 34320K->1016K(125952K), 0.0015129 secs] [Times: user=0.02 sys=0.02, real=0.00 secs] 
WeakReferenceCar's Car is alive for 68454, loop - interview.WeakReferenceCar@776ec8df
WeakReferenceCar's Car has bean collected
Heap
PSYoungGen   total 38400K, used 1986K [0x00000000d5e00000, 0x00000000da900000, 0x0000000100000000)
eden space 33280K, 2% used [0x00000000d5e00000,0x00000000d5ef6b70,0x00000000d7e80000)
from space 5120K, 19% used [0x00000000d7e80000,0x00000000d7f7a020,0x00000000d8380000)
to  space 5120K, 0% used [0x00000000da400000,0x00000000da400000,0x00000000da900000)
ParOldGen    total 87552K, used 16K [0x0000000081a00000, 0x0000000086f80000, 0x00000000d5e00000)
object space 87552K, 0% used [0x0000000081a00000,0x0000000081a04000,0x0000000086f80000)
Metaspace    used 3547K, capacity 4564K, committed 4864K, reserved 1056768K
class space  used 381K, capacity 388K, committed 512K, reserved 1048576K

可以看到在68454循环之后，WeakReferenceCar关联的对象Car被回收掉了，注意是弱引用关联的对象car被回收，而不是弱引用本身wrc被回收。

WeakReference的一个特点是它何时被回收是不可确定的, 因为这是由GC运行的不确定性所确定的. 所以, 一般用weak reference引用的对象是有价值被cache, 而且很容易被重新被构建, 且很消耗内存的对象.

在weak reference指向的对象被回收后, weak reference本身其实也就没有用了. java提供了一个ReferenceQueue来保存这些所指向的对象已经被回收的reference. 用法是在定义WeakReference的时候将一个ReferenceQueue的对象作为参数传入构造函数.

以上就是Java 中的弱引用是什么的详细内容，更多关于Java 弱引用的资料请关注码农之家其它相关文章！

精选文章4

11小时12分钟前整理

什么是MEAN?JavaScript编程中的MEAN是什么意思？

前段日子看到一篇文章提到MEAN这个词，什么是MEAN？

其实MENA就是 MongoDB（非关系数据库） + Express（模板引擎） + AngularJS（MVC javascript库） + NodeJS（服务器脚本）的简称。

它们共同构造 基于 javascript 的 现代web应用全栈开发工具。

MongoDB：

是一种强大、灵活、可扩展的数据存储方式。

它扩展了关系型数据库的众多有用功能，如辅助索引、范围查询、和排序、它内置的对MapReduce式聚合的支持和对地理空间索引的支持。

它将传统数据库行(row)的概念换成，文档(document)模型，所谓文档模型其实就是一个数组对象。

我们来看一下文档模型：

{“_id” : 1 , “greeting” : “hello,world!” , “foo” : 3}

每个文档都会带有一个_id的字段，该文档模型代表数据库中有一条记录,包含字段 greeting , foo 和  _id；

Express：

关于末班引擎Express，我想用按句话来描述它：

是一个简洁而灵活的node.jsWeb应用框架, 提供一系列强大特性帮助你创建各种Web应用。

丰富的HTTP工具以及来自Connect框架的中间件随取随用，创建强健、友好的API变得快速又简单

Express 不对 node.js 已有的特性进行二次抽象，我们只是在它之上扩展了Web应用所需的功能

AngularJS：

AngularJS是由google开发的一款js库，它与backone一样同为MVC脚本库。

几乎每种语言的第一课都是讲hello world，按照惯例我们也来一个：

<html ng-app>

声明了该页面使用angularJS，当加载该页时，标记ng-app告诉AngularJS处理整个HTML页并引导应用。
这个例子在页面打印hello world，有的人就奇怪了，hello world搞这么复杂干嘛。

其实{{}}里内容是一种数据绑定的形式，看完下个例子你就知道它的强大之处了。

我门接着看下一个例子：

在浏览器里打开这个页面，然后试着在输入框输入随意字符，你会发现这些输入的字符立即更新显示在问候语中。 是不是很神奇？

的念。 输入框的任何更改会立即反映到模型变量（一个方向），模型变量的任何更改都会立即反映到问候语文本中（另一方向）。

该示例有一下几点重要的注意事项：

1. 文本输入指令<input ng-model=”yourname” />绑定到一个叫yourname 的模型变量。

2. 双大括号标记将yourname 模型变量添加到问候语文本。

3. 你不需要为该应用另外注册一个事件侦听器或添加事件处理程序！

NodeJS

是由Ryan Dahl开发的一款高性能服务器js平台。

它是集于V8引擎开发的，V8引擎是google开发的 javascript引擎，不是汽车的V8引擎 – -是一款高性能引擎，它的性能远远超越其他脚本语言。

nodeJS使用的是 异步I / O的通信方式，这种方式和AJAX很类似：

nodejs的请求方式：

我们再看下面这个例子：

当同时执行两个请求的时候，总耗时取决于耗时最多的那个，而不是两个请求的耗时总和，因为他们两个是并行的。

nodejs高性能的另一个原因是基于事件驱动：

node将前端浏览器中的 事件 引入后端，配合异步I/O，将事件点暴露给业务逻辑。

事件的变成方式具有轻量级，松耦合，只关注事物点等优势。

精选文章5 Java线程阻塞

18小时39分钟前整理

聊聊Java中是什么方法导致的线程阻塞

一、为什么引入线程阻塞机制？

为了解决对共享存储区的访问冲突，Java 引入了同步机制，现在让我们来考察多个线程对共享资源的访问，显然同步机制已经不够了，因为在任意时刻所要求的资源不一定已经准备好了被访问，反过来，同一时刻准备好了的资源也可能不止一个。为了解决这种情况下的访问控制问题，Java 引入了对阻塞机制的支持。

阻塞指的是暂停一个线程的执行以等待某个条件发生（如某资源就绪），学过操作系统的同学对它一定已经很熟悉了。Java 提供了大量方法来支持阻塞，下面让我们逐一分析。

二、Java中实现线程阻塞的方法：

（1）线程睡眠：Thread.sleep (long millis)方法，使线程转到阻塞状态。millis参数设定睡眠的时间，以毫秒为单位。当睡眠结束后，就转为就绪（Runnable）状态。sleep()平台移植性好。

（2）线程等待：Object类中的wait()方法，导致当前的线程等待，直到其他线程调用此对象的 notify() 唤醒方法。这个两个唤醒方法也是Object类中的方法，行为等价于调用 wait() 一样。wait() 和 notify() 方法：两个方法配套使用，wait() 使得线程进入阻塞状态，它有两种形式，一种允许 指定以毫秒为单位的一段时间作为参数，另一种没有参数，前者当对应的 notify() 被调用或者超出指定时间时线程重新进入可执行状态，后者则必须对应的 notify() 被调用.

（3）线程礼让，Thread.yield() 方法，暂停当前正在执行的线程对象，把执行机会让给相同或者更高优先级的线程。yield() 使得线程放弃当前分得的 CPU 时间，但是不使线程阻塞，即线程仍处于可执行状态，随时可能再次分得 CPU 时间。调用 yield() 的效果等价于调度程序认为该线程已执行了足够的时间从而转到另一个线程.

（4）线程自闭，join()方法，等待其他线程终止。在当前线程中调用另一个线程的join()方法，则当前线程转入阻塞状态，直到另一个进程运行结束，当前线程再由阻塞转为就绪状态。

（5）suspend() 和 resume() 方法：两个方法配套使用，suspend()使得线程进入阻塞状态，并且不会自动恢复，必须其对应的resume() 被调用，才能使得线程重新进入可执行状态。典型地，suspend() 和 resume() 被用在等待另一个线程产生的结果的情形：测试发现结果还没有产生后，让线程阻塞，另一个线程产生了结果后，调用 resume() 使其恢复。Thread中suspend()和resume()两个方法在JDK1.5中已经废除，不再介绍。因为有死锁倾向。

这里，笔者放入一张线程生命周期的经典图片，来帮助读者理解，里面展示了一个线程从创建->运行->阻塞->运行->死亡的全过程：

三、常用线程名词解释

主线程：JVM调用程序main()所产生的线程。

当前线程：这个是容易混淆的概念。一般指通过Thread.currentThread()来获取的进程。

后台线程：指为其他线程提供服务的线程，也称为守护线程。JVM的垃圾回收线程就是一个后台线程。用户线程和守护线程的区别在于，是否等待主线程依赖于主线程结束而结束

前台线程：是指接受后台线程服务的线程，其实前台后台线程是联系在一起，就像傀儡和幕后操纵者一样的关系。傀儡是前台线程、幕后操纵者是后台线程。由前台线程创建的线程默认也是前台线程。可以通过isDaemon()和setDaemon()方法来判断和设置一个线程是否为后台线程。

可见进程：可见进程是指一些不在前台，但用户依然可见的进程，举例来说：各种widget、输入法等，都属于visibe。这部分进程虽然不在前台，但与我们的使用也是密切相关，我们并不希望它被系统终止。

“前台可见进程服务于后台空进程”——这是记录线程重要性的口诀，

重要性一次递减即，前台进程>可见进程>服务进程>后台进程>空进程。

线程类的一些常用方法：

sleep(): 强迫一个线程睡眠Ｎ毫秒。

isAlive(): 判断一个线程是否存活。

join(): 等待线程终止。

activeCount(): 程序中活跃的线程数。

enumerate(): 枚举程序中的线程。

currentThread(): 得到当前线程。

isDaemon(): 一个线程是否为守护线程。

setDaemon(): 设置一个线程为守护线程。(用户线程和守护线程的区别在于，是否等待主线程依赖于主线程结束而结束)

setName(): 为线程设置一个名称。

wait(): 强迫一个线程等待。

notify(): 通知一个线程继续运行。

setPriority(): 设置一个线程的优先级。

补充：java处理线程阻塞的小技巧

在java中我们使用多线程去处理一些业务，如果业务比较复杂且当并发量有挺大的时候，很有可能出现线程阻塞的问题。

案例：

有一个触发接口，根据触发的信息内部开启多个线程去执行业务，每个线程都会去执行两种业务：私有业务（比如调用不同的接口）、公共业务（比如执行存储、mq发送等等），当私有业务处理时间很快而公共业务处理时间比较长，这样的情景下就可以把私有业务和公共业务分到不同线程执行。

例如：

当触发了这个接口，根据接口触发的信息，需要开启10个线程，那么就可以创建10个线程去执行它的私有业务，然后再额外创建一个线程去拿到前面那10个线程的执行返回结果并进行公共业务的处理。

这样有个好处，就是能让线程池很快的回收线程，能有效防止线程的阻塞

量化：

单个私有业务1秒钟能执行完成，单个公共业务需要5秒钟才能执行完成，如果接口被触发，发现需要创建100个线程执行，那么线程池回收这些线程池至少需要等待6秒，如果按照前面说的分成两个线程，那么就需要创建101个线程，而1秒后就能回收掉执行完成的100个线程

但是这里需要做权衡，如果接口被触发的时候发现需要开启的线程比较多且公共业务很耗时，这种情况下执行公共业务只有单个线程同步执行，那么这个线程就会执行比较长的时间，所以执行公共业务的时候也可根据实际情况开启多个线程。

下面写了个小demo：

1.私有业务的类：

@Component
public class Calculation {
  public Result cal(String req, int a, int b) {
    System.out.println("请求id:" + req + "  结果:" + (a + b));
    return new Result(req, a + b);
  }
}

2.公共业务的类：

@Component
public class SomethingElse {
  public void doElse(Result result) {
    try {
      System.out.println(Thread.currentThread().getName() + " : 开始做其他事情,请求号:" + result.getReq() + " ,请求结果:" + result.getSum());
      Thread.sleep(2000);
      System.out.println(Thread.currentThread().getName() + " : 完成做其他事情,请求号:" + result.getReq() + " ,请求结果:" + result.getSum());
    } catch (InterruptedException e) {
    }
  }
}

3.私有业务的线程类：

public class CallTask implements Callable<Result> {
  private String req;
  private int a;
  private int b;
  @Override
  public Result call() throws Exception {
    Calculation calculation = Main.applicationContext.getBean(Calculation.class);
    return calculation.cal(req, a, b);
  }
  public CallTask(String req, int a, int b) {
    this.req = req;
    this.a = a;
    this.b = b;
  }
  // getter and setter 等等
}

4.公共业务的线程类：

public class ElseTask implements Runnable {
  private CompletionService<Result> cs;
  private int threadCount;
  public ElseTask(CompletionService<Result> cs, int threadCount) {
    this.cs = cs;
    this.threadCount = threadCount;
  }
  @Override
  public void run() {
    SomethingElse somethingElse = Main.applicationContext.getBean(SomethingElse.class);
    doElse(somethingElse);
  }
  private void doElse(SomethingElse somethingElse) {
    try {
      for (int i = 0; i < threadCount; i++) {
        Future<Result> take = cs.take();
        Result result = take.get();
        somethingElse.doElse(result);
      }
    } catch (Exception e) {
    }
  }
  // getter and setter 等等
}

6.测试主方法：

@Service
public class Main implements ApplicationContextAware {
  public static ApplicationContext applicationContext = null;
  public static void main(String[] args) throws InterruptedException {
    AbstractApplicationContext appContext = new ClassPathXmlApplicationContext("application01.xml");
    ExecutorService executorService = Executors.newFixedThreadPool(100);
    CompletionService<Result> cs = new ExecutorCompletionService(executorService);
    //这里启动执行计算的线程
    cs.submit(new CallTask("req001", 0, 1));
    cs.submit(new CallTask("req002", 0, 2));
    cs.submit(new CallTask("req003", 0, 3));
    cs.submit(new CallTask("req004", 0, 4));
    cs.submit(new CallTask("req005", 0, 5));
    //专门的监控线程，并执行其他耗时的线程
    executorService.execute(new ElseTask(cs, 5));
    executorService.shutdown();
    appContext.registerShutdownHook();
  }
  @Override
  public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
    this.applicationContext = applicationContext;
  }
}

执行结果如下：

核心思想： 将多线程的公有的业务抽出来（前提是公有业务比较耗时，不然就没必要了）在其他线程里面执行。

以上为个人经验，希望能给大家一个参考，也希望大家多多支持码农之家。如有错误或未考虑完全的地方，望不吝赐教。

精选文章6

16小时31分钟前整理

详解javascript中的babel到底是什么

javascript在不断的发展，各种新的标准和提案层出不穷，但是由于浏览器的多样性，导致可能几年之内都无法广泛普及，babel可以让你提前使用这些语言特性，他是一种用途很多的javascript编译器，他把最新版的javascript编译成当下可以执行的版本，简言之，利用babel就可以让我们在当前的项目中随意的使用这些新最新的es6，甚至es7的语法。说白了就是把各种javascript千奇百怪的语言统统专为浏览器可以认识的语言。

新建项目:npm init

安装babel-cli:npm i babel-cli --save-dev

新建一个文件index.js

let numbers = [1,2,3];
let dou = numbers.map((number)=>number*2);
console.log(dou);

这是es6最新的语法，map遍历数组并输出

然后用babel来编译这段代码，不编译，直接运行，可能会报错，编译成标准的js语言compiled.js

babel index.js -o compiled.js

项目中自动生成compiled.js

打开compiled.js 文件，发现并没有起作用，相当于复制过来了，其实我们在在用babel的时候是需要配置文件泪完成编译的，

新建配置.babelrc文件

{
  "plugins":[ ],
  "presets":[ ]
}

下面来一个预设，它可以把es6的代码编译为es5

npm i babel-preset-es2015 --save-dev

安装完后把这插件配置到.babelrc文件

{
  "plugins":[ ],
  "presets":["es2015"]
}

再次运行编译

打开compiled.js文件

变了

var numbers = [1, 2, 3];
var dou = numbers.map(function (number) {
 return number * 2;
});
console.log(dou);

接下来在编译一段es7的代码，es7编译为es5

我们需要一个插件来完成

npm i babel-plugin-transform-object-rest-spread --save-dev

然后把这个插件配置到.babelrc文件中去

{
  "plugins":["transform-object-rest-spread"],
  "presets":["es2015"]
}

let mike = {name:'mike',age:40};
mike={...mike,sex:'男'};
console.log(mike);

然后运行编译命令

打开compiled.js

'use strict';

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };


var mike = { name: 'mike', age: 40 };
mike = _extends({}, mike, { sex: '男' });
console.log(mike);

这个插件启示就是添加了一个_extends方法来完成这个功能

总结：

babel的核心概念就是利用一系列的plugin来管理编译案列，通过不同的plugin，他不仅可以编译es6的代码，还可以编译react JSX语法或者别的语法，甚至可以使用还在提案阶段的es7的一些特性，这就足以看出她的可扩展性。在以后的博客，会介绍他和webpack，react如何共同创建一个完美的开发环境。

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持码农之家。

精选文章7

5小时49分钟前整理

浅谈Java中的this作为返回值时返回的是什么

有时会遇到this作为返回值的情况，那么此时返回的到底是什么呢？

返回的是调用this所处方法的那个对象的引用，读起来有点绕口哈，有没有想起小学语文分析句子成份的试题，哈哈。

一点点分析的话，主干是“返回的是引用”；

什么引用呢？“那个对象的引用”；

哪个对象呢？“调用方法的那个对象”；

调用的哪个方法呢？“调用的是this所位于的方法”；这样就清楚了。

再总结一下就是，this作为返回值时，返回的是调用某方法的对象的引用，这个方法正是包含“return this;”这行命令的那个方法；更简单点说，就是谁调用返回的就是谁。

为了更清楚、直观的理解问题，下面以简单的例子说明。

包human中定义了Person类，代码如下：

package human;

public class Person {
 String name;
 int age;
 
 public Person() {
  
 }
 public Person(String n, String g) {
  name = n;
  gender = g;
 }

 
 //test:this作返回值
 Person reThis1() {
  Person per = new Person("lu","female");
  System.out.println("reThis1 per:" + per.name);
  return this;
 }
 Person reThis2() {
  Person per = reThis1();
  System.out.println("reThis2 per:" + per.name);
  return this;
 }
 Person reThis3() {
  name = "ma";
  return this;
 }
 static void equRefer(Person per1, Person per2) {
  if(per1 == per2)
   System.out.println("per1指向的对象没有改变，仍与per2指向同一个对象");
  else
   System.out.println("per1指向的对象已改变，与per2指向不同的对象");
  System.out.println("per1:" + per1.name);
  System.out.println("per2:" + per2.name);
 }
 
 public static void main(String[] args) {
  Person per1 = new Person("liu","female");
  Person per2 = per1;
  
  per1 = per1.reThis1();
  Person.equRefer(per1, per2);
   
  per1 = per1.reThis2();
  Person.equRefer(per1, per2);
  
  System.out.println("调用reThis3之前，per1.name=" + per1.name);
  per1 = per1.reThis3();
  System.out.println("调用reThis3之后，per1.name=" + per1.name);
 }
}

输出结果如下：

reThis1 per:lu
per1指向的对象没有改变，仍与per2指向同一个对象
per1:liu
per2:liu
reThis1 per:lu
reThis2 per:liu
per1指向的对象没有改变，仍与per2指向同一个对象
per1:liu
per2:liu
调用reThis3之前，per1.name=liu
调用reThis3之后，per1.name=ma

逐句分析执行过程：

(1).第1句：Person per1 = new Person("liu","female");

创建一个Person对象，将name初始化为“liu”，gender初始化为“female”，并让per1指向该对象。

(2).第2句：Person per2 = per1;

定义一个Person类的对象引用，并与per1指向同一个对象；具体内存分配见图1：

(3).第3句：per1 = per1.reThis1();

由per1调用reThis1()方法，并将返回值赋给per1；reThis1()方法体内定义了一个局部变量per，并创建一个对象，由per指向它；具体内存分配见图2：

紧接着输出reThis1 per:lu；最后返回this，并把返回的值赋给per1。

(4).第4句：Person.equRefer(per1, per2);

调用equRefer(per1,per2)来验证per1的值并未改变；根据下面的输出结果也可知per1仍与per2指向原来的对象，也就是说此时this的值与per1的值是一致的；也可以说，谁调用的返回的就是谁。

输出结果：

per1指向的对象没有改变，仍与per2指向同一个对象
per1:liu
per2:liu

此时的内存图如图3：

(5).第5句：per1 = per1.reThis2();

per1调用reThis2()，由(4)可推测，此时per1的值也不会变，是由per1调用的this所处的方法，所以返回的也是per1；具体来分析的话，reThis2()定义了一个局部变量per，并给其赋值为reThis1()，也就是说reThis2()调用了reThis1()，由(3)、(4)可推知，此时的内存结构是下面这样的：

局部变量per指向的对象与per1是一致的，因为调用reThis1的对象是per1所指的对象，所以返回值也是per1。

此处的输出结果为：

reThis1 per:lu
reThis2 per:liu

(6).第6句：Person.equRefer(per1, per2);

验证上面的结论，per1指向没变，此时的内存分配图如图4所示：

(7).第7、8、9句：

System.out.println("调用reThis3之前，per1.name=" + per1.name);
per1 = per1.reThis3();
System.out.println("调用reThis3之后，per1.name=" + per1.name);

per1调用reThis3()；reThis3()中修改了namer的值，由"liu"改为"ma"，然后返回this。

调用前后的内存结构分别如图6、图7所示：

输出结果：

调用reThis3之前，per1.name=liu
调用reThis3之后，per1.name=ma

再一次验证了上述的结论。

关于为什么使用this，我是这么理解的：由于定义类的时候尚未创建对象，所以不能确定对象到底叫什么，就用this来统一表示，等到具体调用时就可以知道对象的名字了，然后就用对象的引用替换this；所以为了便于记忆，可以理解成谁调用返回的就是谁。

至于返回this有什么意义，我的理解是：记返回this的方法为A，可能A的方法体中对对象的属性做了某些操作或调用了某些方法完成了某些动作，总之，做完这些操作后就把原对象的引用返回，返回后的状态是对象最新的状态，可能与对象调用方法A前不同。

以上这篇浅谈Java中的this作为返回值时返回的是什么就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持码农之家。

精选文章8 Java 悲观锁与乐观锁

5小时12分钟前整理

Java中的悲观锁与乐观锁是什么

乐观锁对应于生活中乐观的人总是想着事情往好的方向发展，悲观锁对应于生活中悲观的人总是想着事情往坏的方向发展。这两种人各有优缺点，不能不以场景而定说一种人好于另外一种人。

悲观锁

总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁（共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程）。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。Java中synchronized和ReentrantLock等独占锁就是悲观锁思想的实现。

乐观锁

总是假设最好的情况，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号机制和CAS算法实现。乐观锁适用于多读的应用类型，这样可以提高吞吐量，像数据库提供的类似于write_condition机制，其实都是提供的乐观锁。在Java中java.util.concurrent.atomic包下面的原子变量类就是使用了乐观锁的一种实现方式CAS实现的。

两种锁的使用场景

从上面对两种锁的介绍，我们知道两种锁各有优缺点，不可认为一种好于另一种，像乐观锁适用于写比较少的情况下（多读场景），即冲突真的很少发生的时候，这样可以省去了锁的开销，加大了系统的整个吞吐量。但如果是多写的情况，一般会经常产生冲突，这就会导致上层应用会不断的进行retry，这样反倒是降低了性能，所以一般多写的场景下用悲观锁就比较合适。

乐观锁常见的两种实现方式 乐观锁一般会使用版本号机制或CAS算法实现。

版本号机制

一般是在数据表中加上一个数据版本号version字段，表示数据被修改的次数，当数据被修改时，version值会加一。当线程A要更新数据值时，在读取数据的同时也会读取version值，在提交更新时，若刚才读取到的version值为当前数据库中的version值相等时才更新，否则重试更新操作，直到更新成功。

举一个简单的例子： 假设数据库中帐户信息表中有一个 version 字段，当前值为 1 ；而当前帐户余额字段（ balance ）为 $100 。

1. 操作员 A 此时将其读出（ version=1 ），并从其帐户余额中扣除 50（100-
2. 在操作员 A 操作的过程中，操作员B 也读入此用户信息（ version=1 ），并从其帐户余额中扣除 20（100-
3. 操作员 A 完成了修改工作，将数据版本号加一（ version=2 ），连同帐户扣除后余额（ balance=$50 ），提交至数据库更新，此时由于提交数据版本大于数据库记录当前版本，数据被更新，数据库记录 version 更新为 2 。
4. 操作员 B 完成了操作，也将版本号加一（ version=2 ）试图向数据库提交数据（ balance=$80 ），但此时比对数据库记录版本时发现，操作员 B 提交的数据版本号为 2 ，数据库记录当前版本也为 2 ，不满足 “ 提交版本必须大于记录当前版本才能执行更新 “ 的乐观锁策略，因此，操作员 B 的提交被驳回。 这样，就避免了操作员 B 用基于 version=1 的旧数据修改的结果覆盖操作员A 的操作结果的可能。
   

CAS算法

即compare and swap（比较与交换），是一种有名的无锁算法。无锁编程，即不使用锁的情况下实现多线程之间的变量同步，也就是在没有线程被阻塞的情况下实现变量的同步，所以也叫非阻塞同步（Non-blocking Synchronization）。CAS算法涉及到三个操作数

需要读写的内存值 V 进行比较的值 A 拟写入的新值 B 当且仅当 V 的值等于 A时，CAS通过原子方式用新值B来更新V的值，否则不会执行任何操作（比较和替换是一个原子操作）。一般情况下是一个自旋操作，即不断的重试。

以上就是Java中的悲观锁与乐观锁是什么的详细内容，更多关于Java 悲观锁与乐观锁的资料请关注码农之家其它相关文章！