首页 / JAVA / java-如何使用EJB 3.0实现适当的计数器bean？

java-如何使用EJB 3.0实现适当的计数器bean？

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了java-如何使用EJB 3.0实现适当的计数器bean？，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含10170字，纯文字阅读大概需要15分钟。

内容图文

[编辑]这个问题是“我如何使用EJB 3和JPA 2.0对实体bean进行原子更改”.应该简单吧？

我试图根据到目前为止得到的答案修复代码.我在Hypersonic中使用JBoss 6.0.0M2(只需下载并调用run.bat).

我的测试用例：创建3个线程并在一个循环中调用testCounterMitLock *()之一500次.因此,成功的测试应打印“ Anzahl eingetragene Zeilen：1500”(3 * 500).

我试过了：

        CounterTestVersion ct = manager.find(CounterTestVersion.class, 1);
        manager.lock(ct, LockModeType.WRITE);
        int wert = ct.getWert();

显然不起作用,因为其他线程可以在应用锁之前更改数据库中的值.因此,我尝试解决此问题：

        CounterTestVersion ct = manager.find(CounterTestVersion.class, 1);
        manager.lock(ct, LockModeType.WRITE);
        manager.refresh (ct);
        int wert = ct.getWert();

refresh()应该给我当前值,隐式查询还应该确保该对象现在被锁定.没有这种运气.让我们尝试使用JPA 2.0：

        CounterTestVersion ct = manager.find(CounterTestVersion.class, 1, LockModeType.WRITE);
        int wert = ct.getWert();

那也行不通.也许锁还不够？

        CounterTestVersion ct = manager.find(CounterTestVersion.class, 1, LockModeType.PESSIMISTIC_WRITE);
        int wert = ct.getWert();

嗯…也不起作用！最后一次绝望的尝试：

        CounterTestVersion ct = manager.find(CounterTestVersion.class, 1, LockModeType.PESSIMISTIC_WRITE);
        manager.flush();
        manager.refresh (ct);
        int wert = ct.getWert();

好吧…谁能解释为什么什么都不起作用？我没主意了.

[EDIT2] PS：要加重侮辱,这是最后一个运行线程的最后输出：

commit/rollback: 441/62

(441 62 = 503)…

这是完整的代码.首先是豆：

package server.kap15;

import java.rmi.RemoteException;

import javax.ejb.*;
import javax.persistence.*;

@Stateful
public class CounterTestBean implements CounterTestRemote, SessionSynchronization {
    @PersistenceContext(unitName = "JavaEE")
    EntityManager manager;

    private int commit = 0;

    private int rollback = 0;

    public void initDatenbank() {
        manager.createNamedQuery("CounterTest.deleteAll").executeUpdate();
        manager.createNamedQuery("TestTabelle.deleteAll").executeUpdate();
        CounterTestVersion ct = new CounterTestVersion();
        ct.setNr(1);
        ct.setVersion(1);
        ct.setWert(1);
        manager.persist(ct);
    }

    public boolean testCounterOhneLock() {
        try {
            CounterTest ct = manager.find(CounterTest.class, 1);
            int wert = ct.getWert();
            ct.setWert(wert + 1);
            TestTabelle tt = new TestTabelle();
            tt.setNr(wert);
            manager.persist(tt);
            manager.flush();
            return true;
        } catch (Throwable t) {
            return false;
        }
    }

    public boolean testCounterMitLock() {
        try {
            CounterTestVersion ct = manager.find(CounterTestVersion.class, 1);
            manager.lock(ct, LockModeType.WRITE);
            int wert = ct.getWert();
            ct.setWert(wert + 1);
            TestTabelle tt = new TestTabelle();
            tt.setNr(wert);
            manager.persist(tt);
            manager.flush();
            return true;
        } catch (Throwable t) {
            return false;
        }
    }

    public boolean testCounterMitLock2() {
        try {
            CounterTestVersion ct = manager.find(CounterTestVersion.class, 1);
            manager.lock(ct, LockModeType.WRITE);
            manager.refresh (ct);
            int wert = ct.getWert();
            ct.setWert(wert + 1);
            TestTabelle tt = new TestTabelle();
            tt.setNr(wert);
            manager.persist(tt);
            manager.flush();
            return true;
        } catch (Throwable t) {
            return false;
        }
    }

    public boolean testCounterMitLock3() {
        try {
            CounterTestVersion ct = manager.find(CounterTestVersion.class, 1, LockModeType.WRITE);
            int wert = ct.getWert();
            ct.setWert(wert + 1);
            TestTabelle tt = new TestTabelle();
            tt.setNr(wert);
            manager.persist(tt);
            manager.flush();
            return true;
        } catch (Throwable t) {
            return false;
        }
    }

    public boolean testCounterMitLock4() {
        try {
            CounterTestVersion ct = manager.find(CounterTestVersion.class, 1, LockModeType.PESSIMISTIC_WRITE);
            int wert = ct.getWert();
            ct.setWert(wert + 1);
            TestTabelle tt = new TestTabelle();
            tt.setNr(wert);
            manager.persist(tt);
            manager.flush();
            return true;
        } catch (Throwable t) {
            return false;
        }
    }

    public boolean testCounterMitLock5() {
        try {
            CounterTestVersion ct = manager.find(CounterTestVersion.class, 1, LockModeType.PESSIMISTIC_WRITE);
            manager.flush();
            manager.refresh (ct);
            int wert = ct.getWert();
            ct.setWert(wert + 1);
            TestTabelle tt = new TestTabelle();
            tt.setNr(wert);
            manager.persist(tt);
            manager.flush();
            return true;
        } catch (Throwable t) {
            return false;
        }
    }

    public boolean testCounterMitVersion() {
        try {
            CounterTestVersion ctv = manager.find(CounterTestVersion.class, 1);
            int wert = ctv.getWert();
            ctv.setWert(wert + 1);
            manager.flush();
            TestTabelle tt = new TestTabelle();
            tt.setNr(wert);
            manager.persist(tt);
            manager.flush();
            return true;
        } catch (OptimisticLockException e) {
            System.out.println(">>> Versionskonflikt !");
            return false;
        } catch (Throwable t) {
            System.out.println(t.getMessage());
            return false;
        }
    }

    public long anzTestZeilen() {
        Query query = manager.createNamedQuery("TestTabelle.anzZeilen");
        Long anzahl = (Long) query.getSingleResult();
        return anzahl;
    }

    public void afterBegin() throws EJBException, RemoteException {
    }

    public void beforeCompletion() throws EJBException, RemoteException {
    }

    public void afterCompletion(boolean committed) throws EJBException,
    RemoteException {
        if (committed)
            commit++;
        else
            rollback++;
        System.out.println("commit/rollback: " + commit + "/" + rollback);
    }
}

远程接口：

package server.kap15;

import javax.ejb.Remote;

@Remote
public interface CounterTestRemote {
    public void initDatenbank();

    public boolean testCounterOhneLock();

    public boolean testCounterMitLock();
    public boolean testCounterMitLock2();
    public boolean testCounterMitLock3();
    public boolean testCounterMitLock4();
    public boolean testCounterMitLock5();

    public boolean testCounterMitVersion();

    public long anzTestZeilen();
}

persistence.xml：

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
        http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd"
    version="1.0">
    <persistence-unit name="JavaEE">
        <jta-data-source>java:DefaultDS</jta-data-source>
    </persistence-unit>
</persistence>

测试客户端：

package client.kap15;

import java.util.Properties;
import javax.naming.*;
import javax.rmi.PortableRemoteObject;
import server.kap15.CounterTestRemote;

public class CounterTestMitLock extends Thread {
    CounterTestRemote ctr;

    public static void main(String[] args) {
        try
        {
            testMitLock();
            testMitLock2();
            testMitLock3();
            testMitLock4();
            testMitLock5();
        }
        catch (Exception e)
        {
            e.printStackTrace ();
        }
    }

    static int N = 3;
    static CounterThread[] ct = new CounterThread[N];

    private static void testMitLock () throws InterruptedException
    {
        System.out.println("--- Counter Test MIT Lock ----------------------");
        System.out.println("Testinstanzen erzeugen...");
        for (int i=0; i<N; i++)
            ct[i] = new CounterThreadMitLock();

        runTest ();
    }

    private static void testMitLock2 () throws InterruptedException
    {
        System.out.println("--- Counter Test MIT Lock2 ----------------------");
        System.out.println("Testinstanzen erzeugen...");
        for (int i=0; i<N; i++)
            ct[i] = new CounterThreadMitLock2();

        runTest ();
    }

    private static void testMitLock3 () throws InterruptedException
    {
        System.out.println("--- Counter Test MIT Lock3 ----------------------");
        System.out.println("Testinstanzen erzeugen...");
        for (int i=0; i<N; i++)
            ct[i] = new CounterThreadMitLock3();

        runTest ();
    }

    private static void testMitLock4 () throws InterruptedException
    {
        System.out.println("--- Counter Test MIT Lock4 ----------------------");
        System.out.println("Testinstanzen erzeugen...");
        for (int i=0; i<N; i++)
            ct[i] = new CounterThreadMitLock4();

        runTest ();
    }

    private static void testMitLock5 () throws InterruptedException
    {
        System.out.println("--- Counter Test MIT Lock5 ----------------------");
        System.out.println("Testinstanzen erzeugen...");
        for (int i=0; i<N; i++)
            ct[i] = new CounterThreadMitLock5();

        runTest ();
    }

    private static void runTest () throws InterruptedException
    {
        System.out.println("Datenbank initialisieren...");
        ct[0].ctr.initDatenbank();

        System.out.println("Test durchführen...");
        for (int i=0; i<N; i++)
            ct[i].start();

        System.out.println("Auf Ende warten...");
        for (int i=0; i<N; i++)
            ct[i].join();

        System.out.println("Anzahl eingetragene Zeilen: " + ct[0].ctr.anzTestZeilen());
    }

    private static CounterTestRemote verbinden() {
        try {
            Properties p = new Properties();
            p.put(Context.INITIAL_CONTEXT_FACTORY, "org.jnp.interfaces.NamingContextFactory");
            p.put(Context.URL_PKG_PREFIXES, "org.jboss.naming:org.jnp.interfaces");
            p.put(Context.PROVIDER_URL, "jnp://localhost:1099");
            Context ctx = new InitialContext(p);

            Object ref = ctx.lookup("CounterTestBean/remote");
            CounterTestRemote ctr = (CounterTestRemote) PortableRemoteObject.narrow(ref, CounterTestRemote.class);

            return ctr;
        } catch (NamingException e) {
            System.out.println("ERROR - NamingException!");
            System.exit(-1);
        }
        return null;
    }

    public abstract static class CounterThread extends Thread
    {
        protected CounterTestRemote ctr;

        public CounterThread ()
        {
            this.ctr = verbinden ();
        }

        public void run() {
            for (int i = 0; i < 500; i++)
                test ();
        }

        public abstract void test ();
    }

    public static class CounterThreadMitLock extends CounterThread
    {
        @Override
        public void test ()
        {
            this.ctr.testCounterMitLock();
        }

    }

    public static class CounterThreadMitLock2 extends CounterThread
    {
        @Override
        public void test ()
        {
            this.ctr.testCounterMitLock2();
        }

    }

    public static class CounterThreadMitLock3 extends CounterThread
    {
        @Override
        public void test ()
        {
            this.ctr.testCounterMitLock3();
        }

    }

    public static class CounterThreadMitLock4 extends CounterThread
    {
        @Override
        public void test ()
        {
            this.ctr.testCounterMitLock4();
        }

    }

    public static class CounterThreadMitLock5 extends CounterThread
    {
        @Override
        public void test ()
        {
            this.ctr.testCounterMitLock5();
        }

    }
}

解决方法:

由于所有锁定模式都不起作用,因此我尝试使用手动SELECT … FOR UPDATE尝试ewernli的解决方案.那给出了一个有趣的例外：“意外令牌FOR”.所以我看了看数据库.

JBoss默认安装为Hypersonic 1.8(HSQLDB),不支持行锁定.尊敬的JBoss开发人员：如果不支持锁定模式,则JPA实现应该引发异常.

因此,我添加了Oracle数据源并更改了persistence.xml.之后,将执行两个测试：

        CounterTestVersion ct = manager.find(CounterTestVersion.class, 1, LockModeType.PESSIMISTIC_WRITE);
        int wert = ct.getWert();

和

    Query query = manager.createNativeQuery ("select * from COUNTER_TEST where NR = 1 for update", CounterTestVersion.class);
    CounterTestVersion ct = (CounterTestVersion)query.getSingleResult ();
    int wert = ct.getWert ()+1;

这很有趣.它也应该与LockModeType.PESSIMISTIC_FORCE_INCREMENT一起使用.在这种情况下,我在日志中看到此错误：

ORA-00054: resource busy and acquire with NOWAIT specified

这发生在调用manager.find()中.我看不到为什么两者在负载阶段的行为会有所不同.也许是JBoss或Hibernate中的错误.

内容总结

以上是互联网集市为您收集整理的java-如何使用EJB 3.0实现适当的计数器bean？全部内容，希望文章能够帮你解决java-如何使用EJB 3.0实现适当的计数器bean？所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/670426.html

来源：【匿名】

【上一篇】java-尝试在spring中设置外部化属性【下一篇】JAVA/JSP学习系列之五

更多 ►

【java-如何使用EJB 3.0实现适当的计数器bean？】教程文章相关的互联网学习教程文章

Java 8 LongAdders：管理并发计数器的正确方式【图】

转自：http://www.importnew.com/11345.html我只是喜欢新鲜的事物，而Java 8 有很多新东西。这次我想讨论其中我最喜欢的之一：并发加法器。这是一个新的类集合，他们用来管理被多线程读写的计数器。这个新的API在显著提升性能同时，仍然保持了简单直接的特点。多核架构到来之后人们就解决着并发计数器，让我们来看看到现在为止Java提供了哪些解决并发计数器的选项，并对比一下他们与新API的性能。脏计数器 – 这种方法意味着一个常...

java 5线程中 Semaphore信号灯，CyclicBarrier类，CountDownLatch计数器以及Exchanger类使用【代码】

先来讲解一下Semaphore信号灯的作用: 可以维护当前访问自身的线程个数，并提供了同步机制，使用semaphore可以控制同时访问资源的线程个数例如，实现一个文件允许的并发访问数。请看下面的演示代码: 1publicclass SemaphoreTest2{3publicstaticvoid main(String[] args)4 {5//创建一个带有缓存的线程池 6 ExecutorService service = Executors.newCachedThreadPool();7//创建三个信号灯 8final Semaphore sp = new Sema...

java – 使用Hadoop计数器 – 多个作业【代码】

我正在使用Hadoop开发mapreduce项目.我目前有3个连续的工作. 我想使用Hadoop计数器,但问题是我想在第一个作业中进行实际计数,但是在第三个作业的reducer中访问计数器值. 我怎样才能做到这一点？我应该在哪里定义枚举？我是否需要通过它才能完成第二份工作？它还有助于查看一些代码示例,因为我还没有找到任何东西. 注意：我使用的是Hadoop 2.7.2 编辑：我已经尝试过解释here的方法,但没有成功.我的情况不同,因为我想从不同的工作访问...

Java多线程编程1：CountDownLatch计数器【代码】

前言：多个线程同时查询一张表，最后汇总查询结果返回，那么就存在一个问题，如何判断多个线程是否全部已经处理完成。CountDownLatch 能够使一个线程在等待另外一些线程完成各自工作之后，再继续执行。它相当于是一个计数器，这个计数器的初始值就是线程的数量，每当一个任务完成后，计数器的值就会减一，当计数器的值为 0 时，表示所有的线程都已经完成任务了，然后在 CountDownLatch 上等待的线程就可以恢复执行接下来的任务。一...

Java JVM——4.程序计数器【代码】【图】

简介JVM中的程序计数寄存器（Program Counter Register），Register的命名源于CPU的寄存器，寄存器存储指令相关的现场信息，CPU只有把数据装载到寄存器才能够运行。这里的寄存器，并非是广义上所指的物理寄存器，将其翻译为PC计数器（或指令计数器）更为贴切一些（也称为程序钩子），并且也不容易引起一些不必要的误会。JVM中的PC寄存器是对物理PC寄存器的一种抽象模拟。PC 寄存器程序计数器是一块很小的内存空间，几乎可以忽略不记...

Java多线程工具类之循环栅栏计数器【图】

Java多线程下循环计数器本文主要内容：CyclicBarrier(下文中凯哥就用cycBar来代替)定义介绍；举例说明；代码演示；从源码来看原理及总结；CyclicBarrier与CountDownLatch(下文就用CountDown来代替)比较。本篇是《凯哥(凯哥Java:kagejava)并发编程学习》系列之《并发工具类》教程的第二篇：《Java多线程下循环计数器》。编辑一：CyclicBarrier是什么cycBar是什么呢？来看看JDKAPI文档中是怎么介绍这个对象的：翻译后大概意思：允许一...

java-SpringBoot中Rest Api的计数器指标【代码】

最好的方法是计算一次在春季启动中API响应其成功/失败响应被触发的次数. 我的想法是,在应用程序启动和调用api时,使用post构造启动一个新线程,然后对每个新的唯一请求使用计数器服务,以计算该特定请求触发了多少个api以及其中有多少成功或失败. 如果你们有什么建议,推荐一些新方法.解决方法:您不必从头开始创建,只需使用内置了此功能的Spring Boot Actuator.只需将以下依赖项添加到您的项目中： pom.xml：<dependency><groupId>org....

java-如何使用EJB 3.0实现适当的计数器bean？【代码】

[编辑]这个问题是“我如何使用EJB 3和JPA 2.0对实体bean进行原子更改”.应该简单吧？我试图根据到目前为止得到的答案修复代码.我在Hypersonic中使用JBoss 6.0.0M2(只需下载并调用run.bat). 我的测试用例：创建3个线程并在一个循环中调用testCounterMitLock *()之一500次.因此,成功的测试应打印“ Anzahl eingetragene Zeilen：1500”(3 * 500). 我试过了：CounterTestVersion ct = manager.find(CounterTestVersion.class, 1);man...

java-为什么此多线程计数器产生正确的结果？【代码】

我正在学习多线程计数器,我想知道为什么无论我运行多少次代码它都能产生正确的结果.public class MainClass {public static void main(String[] args) {Counter counter = new Counter();for (int i = 0; i < 3; i++) {CounterThread thread = new CounterThread(counter);thread.start();}} }public class CounterThread extends Thread {private Counter counter;public CounterThread(Counter counter) {this.counter = counter...

Java 基于 AtomicLong 高并发计数器【代码】

示例代码 AtomicLong 实现的计数器，Java 8 LongAdder更高效！详情 @Service public class EnterpriseNameSuffixService implements InitializingBean { @Autowired private EnterpriseNameSuffixRepository enterpriseNameSuffixRepository; private AtomicLong atomicLong = new AtomicLong(); private static int SUFFIX_SPAN_SIZE = 50; @Override public void afterPropertiesSet() throws Exception {//获取当前记录计数lon...

java-排序比较计数器【代码】

我有这段代码可以对填充有随机数的数组进行排序,并计算完成排序所需的数字比较.我正在使用排序方法选择气泡和合并排序.我有选择区和泡沫区的计数器,但没有合并区,我不知道将其放在何处.这可能是一个简单的答案,但我无法使其正常工作. 码：/************************************************************************ * Selection Sort:* Reads in the array and then searches for the largest number. * After it finds the larg...

java – 如何在Output阶段访问Mapper / Reducer计数器？【代码】

我有一些我在Mapper类中创建的计数器： (使用appengine-mapreduce Java库v.0.5编写的示例)@Override public void map(Entity entity) {getContext().incrementCounter("analyzed");if (isSpecial(entity)){getContext().incrementCounter("special");} }(方法isSpecial只返回true或false,具体取决于实体的状态,与问题无关) 我想在完成处理整个东西时访问那些计数器,在Output类的finish方法中：@Override public Summary finish(Col...

使用并发,线程,静态变量实现GAE / Java计数器【代码】

我已经阅读了很多关于计数器的GAE文章和GAE中令人讨厌的写入限制.我已经看到了带有分片,cron任务,内存缓存等的解决方案.然后我学到了足够多的java线程能够提出问题：Q: Can we implement a counter in servlet threads using concurrency /servlet static varibales?这将带来额外的好处,即减少对数据存储区和内存缓存的写入(花费相同的$),并删除cron要求,因为一系列快速计数器命中中的最后一个servlet将更新数据存储区. 我不太了解...

java – 如何让一个计数器在while循环中工作？【代码】

所以我试着让我们说一下Posx;保持一个数字,然后当用户浏览菜单时,根据他们选择的内容,将向int Posx添加1,0或-1.在添加或减去数字后,我无法让Posx保留数字.我正在尝试浏览数组,我想保留2个整数作为标记,让我知道我目前在数组中的x和y. tl; dr如何在do / while循环中保留一个计数器？这是问题所在：//this variable will hold if we found or not the string in the puzzleboolean found = true;do { //Print out the arrayfor (...

java – 更快的方法来打破循环或增量计数器？【代码】

是否有更快的方法来增加计数器或从外循环中断？while(myArrayList.get(i) > myNumber) {// some operationsif(i + 1 < myArrayList.size())i++;elsebreak; }解决方法:编写代码的更好方法是：for (int i = 0; i < myArrayList.size(); i++) {if (myArrayList.get(i) <= myNumber) break;//Some operations... }

JAVA - 技术教程分类

Java 教程 Java 简介 Java 开发环境配置 Java 基础语法 Java 对象和类 Java 基本数据类型 Java 变量类型 Java 修饰符 Java 运算符 Java 循环结构 Java 条件语句 Java switch case Java Number & Math 类 Java Character 类 Java String 类 Java StringBuffer Java 数组 Java 日期时间 Java 方法 Java Stream、File、IO Java Scanner 类 Java 异常处理 Java 继承 Java Override/Overload Java 多态 Java 抽象类 Java 封装 Java 接口 Java 枚举 Java 包(package) Java 数据结构 Java 集合框架 Java ArrayList Java LinkedList Java HashSet Java HashMap Java Iterator Java Object Java 泛型 Java 序列化 Java 网络编程 Java 多线程编程 Java Applet 基础 Java 文档注释 Java 实例 Java 8 新特性 Java MySQL 连接 Java 9 新特性 Java 测验 java 全部

JAVA - 最热教程

Java在运行项目时候，点击右键的弹框，...nacos配置中心超时问题：java.net.Conn...Java的设计模式（7）— 生产者-消费者模...基于DOM4j和POI实现的XML文件转换为XLS...如何在Java中创建一些变量类型别名使用java8的Stream统计字符串数组中每一...idea插件篇之java内存分析工具(JProfil...cannot cast 'java.lang.Integer' to '...java – Bootstrap.properties中Spring...Java8利用stream流实现数字排序和中文排...

首页 / JAVA / java-如何使用EJB 3.0实现适当的计数器bean？

java-如何使用EJB 3.0实现适当的计数器bean？

内容导读

内容图文

内容总结

内容备注

内容手机端

【java-如何使用EJB 3.0实现适当的计数器bean？】教程文章相关的互联网学习教程文章

Java 8 LongAdders：管理并发计数器的正确方式【图】

java 5线程中 Semaphore信号灯，CyclicBarrier类，CountDownLatch计数器以及Exchanger类使用【代码】

java – 使用Hadoop计数器 – 多个作业【代码】

Java多线程编程1：CountDownLatch计数器【代码】

Java JVM——4.程序计数器【代码】【图】

Java多线程工具类之循环栅栏计数器【图】

java-SpringBoot中Rest Api的计数器指标【代码】

java-如何使用EJB 3.0实现适当的计数器bean？【代码】

java-为什么此多线程计数器产生正确的结果？【代码】

Java 基于 AtomicLong 高并发计数器【代码】

java-排序比较计数器【代码】

java – 如何在Output阶段访问Mapper / Reducer计数器？【代码】

使用并发,线程,静态变量实现GAE / Java计数器【代码】

java – 如何让一个计数器在while循环中工作？【代码】

java – 更快的方法来打破循环或增量计数器？【代码】

JAVA - 相关标签

JAVA - 技术教程分类

JAVA - 最新教程

JAVA - 最热教程