标签: java-threads

public class ObjectCounter {
    private static long numOfInstances = 0;
    public ObjectCounter(){
        synchronized(this){
        numOfInstances++;
        }
    }
    **public static synchronized long getCount(){
        return numOfInstances;
    }**
//vs//
    **public static long getCount(){
        return numOfInstances;
    }**
}

如果我运行少量线程,其中一些调用静态函数getCount(),其中一些创建新实例.我希望每次调用getCount()实际数量的实例.

1. 代码中的两个选项有区别吗？
2. 如果我锁定" this"不应该意味着我不能调用,getCount()直到构造函数退出synchronized块(假设我没有在getCount()上写同步).
3. 如果我在代码中的某个地方执行同步块,它是仅锁定同步块还是所有" this"代码？
4. 从这里开始编辑:谢谢大家,这非常有帮助,但我还有一些问题可以回答你的问题.
5. 如果我理解正确,synchronized(this)块不会影响(或连接到)静态同步函数(以锁定术语而不是numOfInstances增量)？
6. 是否有更好的选项来使增量和getCount()函数线程安全？(比如打开一个静态对象并执行synchronized(obj)而不是synchronized(this) - 朋友建议).
7. 如果我在ObjectCounter类中有一个f1()方法(非静态),而一个线程在同步(this)中,其他线程可以输入f1()块(不是同步类或者里面有同步块)？
8. 如果我在ObjectCounter中有一个f1()方法(非静态)和f2()方法(非静态),在f1()中我有同步(this)块.当一个线程在同步(this)块中时,其他线程是否可以进入f1()块(不是同步类或内部有同步块)？(假设两个线程在同一个实例上"工作")

`

我正在使用一个源代码分析器,指出不应在Thread实例中调用notifyAll().我试图向管理层说明这一点,但我无法提出解释.有人能帮我吗？？

顺便说一句,这是继承的代码,所以我不负责设计决策!

我有一个代码,其中4个线程同时运行.我想等到所有这4个线程都完成.只有在那之后继续app流程.

我尝试了两种方法:

1. Thread#join(),这种方法按预期工作.之后的代码join()仅在所有线程完成后执行.
2. ExecutorService#shutdown(),这种技术允许执行代码,shutdown()即使并非所有线程都完成也会执行.

代码示例:

ExecutorService service = Executors.newFixedThreadPool(cpuCoresNum);

for (int i = 0; i < cpuCoresNum; i++) {

    service.submit(() -> {
        try {
            foo(); // some long execution function
        } catch (Exception e) {
            e.printStackTrace();
        }
    });
}

service.shutdown();

System.out.println("We're done! All threads are finished!");

我的问题:

• 为什么submit(),shutdown()不要等到所有线程都完成并打印«我们已经完成了!所有线程都已完成!»电话结束后service.shutdown();？

如何在线程间通信中调用特定线程？

在下面的程序中,我有两个线程t1和t2.

当我称之为t1.notify()加薪:

Exception in thread "Thread-1" java.lang.IllegalMonitorStateException
    at java.lang.Object.notify(Native Method)
    at Shared.methodTwo(NotifyThread.java:43)
    at Thread2.run(NotifyThread.java:77)
Error 

class Shared {

    Thread1 t1 ;
    Thread2 t2 ;

    void ThreadInit( Thread1 t1 , Thread2 t2 ) {
        this.t1 = t1 ;
        this.t2 = t2 ;
    }

    synchronized void methodOne()
    {
        Thread t = Thread.currentThread();

        System.out.println(t.getName()+" is relasing the lock and going to wait");

        try
        {
            wait();        //releases the lock of this object and waits
        }
        catch (InterruptedException …

我有一个 Manager 类，多个线程向其中注册自己（用于为UUID每个请求生成唯一标识符），提供要处理的有效负载并从管理器获取相应的响应。我用来java.util.concurrent.ExecutorService启动多个线程。这是测试我的管理器功能的实现 -

public class ManagerTest {
    public static void main(String[] args) {
        try {
            Manager myManager = new Manager();
            // Start listening to the messages from different threads
            myManager.consumeMessages();
            int num_threads = Integer.parseInt(args[0]);
            ExecutorService executor = Executors.newFixedThreadPool(num_threads);

            for (int i = 0; i < num_threads; i++) {
                // class implementation is given below
                Runnable worker = new MyRunnable(myManager);
                executor.execute(worker);
            }
            executor.shutdown();
            // Wait until all threads are finish
            while (!executor.isTerminated()) {

            }
            System.out.println("\nFinished all …

我有以下关于声明主方法同步的dount .

所以阅读这个讨论: 声明主方法同步

我可以读到:

同步可防止多个实例同时执行,这可能是合乎需要的.

那究竟是什么意思呢？

我试着做一个例子:

我有一个非常小的批处理应用程序,可以在数据库上执行一些操作.该应用程序主要由main()方法组成.我编译了一个可以执行的.jar文件.

这意味着将此main()方法声明为同步我不能同时运行此jar文件的2个实例？或者我错过了什么？

我还没有工作multithreading,加入和等待有什么区别,通知方法？差异仅限于获取lock和禁止其他人threads访问它或是否有其他用例？

为什么我应该去wait和notify在multithreading何时join可用于完成thread执行？

如果提供了任何实时示例,将会很有帮助

Java中只有Java 7才能实现并行编程Join/Fork framework.

让我们说在Java中,使用ExecutorService我创建一个4线程的线程池并提交给它说10个任务,这意味着4个线程将开始执行4个任务,其他6个任务将被线程选中,当任何线程完成其任务时.

假设我有一个具有4个内核的四核处理器,我知道一个线程可以在一个内核上运行(这里没有采用超线程概念)所以我的所有4个线程并行工作,1个内核运行1个线程？这不是一个并行编程吗？

编辑: 阅读源 - 这是Java 8播放列表,在第1章中提到可以从Java 7开始实现并行编程.

因此，根据我在Internet上阅读的大多数内容，Java 中可以拥有的线程数上限约为10,000。但是，实际上我可以创建近 500,000 个，此时我的计算机没有响应。（任务管理器有点滑稽——它开始声称虽然我的 16 GB 内存中有 99% 被使用，但使用率最高的程序只使用了大约 300 MB。在一切停止响应后，风扇安静下来，磁盘访问指示灯只是周期性闪烁，让我相信 CPU 和磁盘都没有承受重负载。）我等了大约 15 分钟的一个测试，但从未出现异常（嗯，据我所知）。