小编sen*_*iwu的帖子

int total = (int) Math.ceil(157/32);

为什么它仍然返回4？157/32 = 4.90625,我需要围捕,我环顾四周,这似乎是正确的方法.

我想total作为double类型,但得到4.0.

我究竟做错了什么？

根据JLS，对数组访问表达式的运行时评估的行为如下：

1. 首先，对数组引用表达式进行求值。如果此评估突然完成，则出于相同原因，数组访问将突然完成，并且不评估索引表达式。
2. 否则，将评估索引表达式。如果此评估突然完成，则出于相同原因，阵列访问也会突然完成。
3. 否则，如果数组引用表达式的值为null，则将引发NullPointerException。

因此，此代码将打印：java.lang.NullPointerException，index = 2

class Test3 {
    public static void main(String[] args) {
        int index = 1;
        try {
            nada()[index = 2]++;
        } catch (Exception e) {
            System.out.println(e + ", index=" + index);
        }
    }

    static int[] nada() {
        return null;
    }
}

问题是：出于什么原因，我们需要首先对index = 2表达式求值，而不是在数组引用被评估为null时立即抛出NullPointerException？或者换句话说-为什么1,2,3而不是1,3,2？

我有界面

Interface MyInterface {
  myMethodToBeVerified (String, String);
}

并且接口的实现是

class MyClassToBeTested implements MyInterface {
   myMethodToBeVerified(String, String) {
    …….
   }
}

我有另一堂课

class MyClass {
    MyInterface myObj = new MyClassToBeTested();
    public void abc(){
         myObj.myMethodToBeVerified (new String(“a”), new String(“b”));
    }

}

我正在尝试为MyClass编写JUnit.我已经做好了

class MyClassTest {
    MyClass myClass = new MyClass();

    @Mock
    MyInterface myInterface;

    testAbc(){
         myClass.abc();
         verify(myInterface).myMethodToBeVerified(new String(“a”), new String(“b”));
    }
}

但是我想得到 mockito但是没有被调用,实际上在验证调用时没有与这个模拟器进行零交互.

谁能建议一些解决方案.

我计划在我的公司内部进行Java 8中的新功能和概念的内部演示.

我想关注的是新集合库的并行处理功能.

无论我在哪里阅读Java 8以及对集合库的更多功能样式迭代器的需求,都会提到这将有助于利用当前正常的多核服务器.但很少有人提到这是如何实现的,以及这是否是一个普遍的事实,更不用说任何有关性能的基准.

正如我公司中经验丰富的开发人员声称了解线程并不知道实际线程如何在较低级别工作,我正在尝试收集这方面的一些知识.基于阅读几篇博客等,我做了一系列以下断言.

我会感谢以下几点的反馈(真/假) ..

1. 线程是操作系统中最低的调度单位(是基本的东西,但不是所有应用程序员都知道这个;-))

2. 单线程程序一次只能在一个核心上运行.因此,在四核CPU中,例如不使用75%的CPU.

3. 现有Java集合迭代器的问题在于它是一个外部迭代器,并且不可能(至少开箱即用)将庞大的集合迭代分发给多个线程.新的集合库操作使得可以在不需要处理低级并发问题的情况下实现并发

4. Java 8使用增强的集合库可以使用内部迭代器并行化迭代

   而不是Java 7

   for (Shape s : shapes) {if (s.getColor() == RED)s.setColor(BLUE); }

   我们有Java 8

   shapes.forEach(s -> { if (s.getColor() == RED) s.setColor(BLUE); })

5. 但为了平行上述迭代,必须明确使用parallel()方法Stream API

   private static void printUsingCoolLambda (final List<String> names) { names.parallelStream().forEach(s -> System.out.println(s)); System.out.println("Printed using printUsingCoolLambda"); }

   但即便如此,也不能保证操作将并行完成,因为Javadoc parallelStream()说下面的"返回一个可能并行的{@code Stream},并将此集合作为其源.此方法允许返回顺序流"

6. 最终,无法保证所有核心都将被利用,因为线程调度不是JVM的责任,而是由OS决定.

编辑

我最难得到第5点和第6点.正如各种Java 8博客所说的那样"使用这个新的parallelStream()并且您将获得开箱即用的并行处理(免费,并且您作为应用程序员免于担心这一点)",我的问题用一句话本来应该是真的正确吗？

我正在尝试使用Spring boot/Spring RestController后端从AngularJS前端POST到http:// localhost:9095/translators.

我可以做一个GET,响应如下:

[{"userId":1,"firstName":"John","lastName":"Doe","emailId":"john.doe@inc.com","languages":[{"languageId":1,"languageCode":"gb","source":true}],"translations":[{"translationId":3,"sourceId":1,"sourceText":"Hello","targetId":null,"targetText":null,"translationStatus":"DUE"}],"userType":"TRANSLATOR"}

当我发布下面的json时,我得到错误响应

发布数据:

{
                    firstName: "zen",
                    lastName: "cv",
                    emailId: "email",
                    userType: "TRANSLATOR",
                    languages : [{languageId:1,languageCode:"gb",source:true}]
}

错误:

{
timestamp: 1422389312497
status: 415
error: "Unsupported Media Type"
exception: "org.springframework.web.HttpMediaTypeNotSupportedException"
message: "Content type 'application/json' not supported"
path: "/translators"
}

我确保我的控制器具有正确的Mediatype注释.

@RestController
@RequestMapping("/translators")
public class TranslatorController {
    @Autowired
    private UserRepository repository;

    @RequestMapping(method = RequestMethod.GET)
    public List findUsers() {
        return repository.findAll();
    }

    @RequestMapping(value = "/{userId}", method = RequestMethod.GET)
    public User findUser(@PathVariable Long userId) {
        return …

mapreduce有哪些缺点？mapreduce有很多优点.但我也想知道mapreduce的缺点.

我试图在Spring启动时加载一些数据,但数据没有加载到数据库,虽然我没有收到任何错误.下面是代码

spring:
  debug: true
  datasource:
  username: root
  password: ****
  url: jdbc:mariadb://localhost:3306/customer_registration_service?connectTimeout=100
  driver-class-name: org.mariadb.jdbc.Driver
  initialize: true
  data: data-mysql.sql
  validation-query: SELECT 1
  test-on-borrow: true
jpa:
  database-platform: org.hibernate.dialect.MySQL5InnoDBDialect
  properties:
    hibernate:
      ddl-auto: validate
      naming-strategy: org.springframework.boot.orm.jpa.hibernate.SpringNamingStrategy

我在src/main/resources下有data-mysql.sql

为了强制错误,我试图故意给出一个错误的文件名,但我仍然没有得到任何真正的错误.所以看起来Spring完全忽略了这个设置

编辑:

这是启动日志

[INFO] Scanning for projects...
[INFO]                                                                         
[INFO] ------------------------------------------------------------------------
[INFO] Building customer-registration 1.0-SNAPSHOT
[INFO] ------------------------------------------------------------------------
[INFO] 
[INFO] >>> spring-boot-maven-plugin:1.5.2.RELEASE:run (default-cli) @ customer-registration >>>
[INFO] 
[INFO] --- maven-resources-plugin:2.6:resources (default-resources) @ customer-registration ---
[INFO] Using 'UTF-8' encoding to copy filtered resources.
[INFO] Copying 1 resource
[INFO] Copying 1 resource …

我有一个 Kafka 生产者，它以高速率生成消息（消息键是让我们说用户名和值是他在游戏中的当前分数）。Kafka 消费者处理消费消息的速度相对较慢。这里我的要求是显示最新的分数并避免显示陈旧的数据，权衡可能永远不会显示某些分数。

基本上对于每个用户名，我可能在同一个分区中有数百条消息，但我总是想阅读最新的一条。

一个粗略的解决方案是这样的：生产者在每条消息和实际值写入数据库时​​只发送一个键，该数据库与消费者共享。消费者从队列中读取每个键并从数据库中读取值。在这里，始终读取最新值的目标是通过生产者覆盖数据库中的值来实现的——因此实际上正在读取给定键的消费者实际上将使用最新值。但由于读取和更新次数较多（慢、竞争条件等），该解决方案存在一些缺点。

我正在寻找在 kafka 或 kafka 流中解决这个问题的更自然的方法，我可以以某种方式定义从每个键的数据流中获取键的最新值。谢谢！

我正在阅读Oracle Java EE 6 教程和“Beans as Injectable Objects”部分下，它说

可以注入以下类型的对象：

（几乎）任何 Java 类

会话豆......

无法注入的 Java 类的示例是什么？这只是他们提到的一些理论上的技术限制，还是可以注入的类有已知的限制？

在阅读Brian Goetz撰写的Java Concurrency in Practice一书时,我遇到了数据竞赛和竞争条件.

数据竞赛

当有一个由多个线程读取的变量,由至少一个线程写入,并且写入和读取不是时,程序被称为具有数据竞争,因此不是"正确同步"的程序以前发生的关系命令.

比赛条件

当计算的正确性取决于运行时的多个线程的相对定时或交错时,就会出现竞争条件; 换句话说,当得到正确的答案依赖于幸运时间.最常见的竞争条件类型是check-then-act,其中使用可能陈旧的观察来决定下一步该做什么

据我所知,可以通过确保上述一个或多个条件保持错误来避免数据竞争 - 即,通过使共享变量不可变或通过正确访问它们synchronized.

我的问题是关于SingletonFactory的例子,通常用于说明竞争条件.

例如:

public class SingletonFactory {

    private Singleton singleton = null;

    private SingletonFactory() {}

    public Singleton getInstance() {
        if(this.singleton == null) {
            this.singleton = new Singleton();
        }
        return this.singleton;
   }
}

此代码是否也可以被视为导致数据竞争？

我知道使上述程序"完全线程安全"的一种方法是使用双重检查锁定并使类变量volatile.

但是,如果我只是声明Singleton变量volatile,但无法同步初始化变量的代码块,那么它是否可以被视为安全至少wrt"数据竞争",但仍然不安全的竞争条件？总的来说,我仍然在寻找一个没有数据竞争的好的现实例子,但仍然存在潜在的竞争条件!

(一个通常被称为解释数据竞争和竞争条件之间差异的博客并没有帮助我理解这一点)