Java 在自己的线程中执行类_Java_Multithreading

Java 在自己的线程中执行类

java multithreading

Java 在自己的线程中执行类,java,multithreading,Java,Multithreading,我有一个InstanceFactory类，它创建某个类的实例，我们称之为instance类。这些实例是在main（）方法中创建的。在这个实例类上，我当前进行的调用有instance.init（），instance.put（），instance.stop（）由于所有内容都在单个线程中运行，并且我发现了一些性能问题，所以我希望尝试在单独的线程中运行实例为了让实例类在单独的线程中运行，我必须对其进行哪些更改？我是否仍然能够进行相同的调用，例如instance.init（）更新（添加代码）： In

我有一个

InstanceFactory

类，它创建某个类的实例，我们称之为

instance

类。这些实例是在

main（）

方法中创建的。在这个实例类上，我当前进行的调用有

instance.init（）

，

instance.put（）

，

instance.stop（）

由于所有内容都在单个线程中运行，并且我发现了一些性能问题，所以我希望尝试在单独的线程中运行实例

为了让实例类在单独的线程中运行，我必须对其进行哪些更改？我是否仍然能够进行相同的调用，例如

instance.init（）

更新（添加代码）：

InstanceFactory instanceFactory = new InstanceFactory();
try (Instance instance = instanceFactory.create()) {
    instance.init();
    instance.doStuff();
    while ((input = reader.readNext()) != null) {
        instance.put(input);
    }
}

实例应该在自己的线程中运行。

您可能可以使用

如果

instance.put（）

是线程安全的，则可以替换

Executors.newSingleThreadExecutor（）与执行器。例如，newCachedThreadPool（）

InstanceFactory instanceFactory = new InstanceFactory();
ExecutorService executor = Executors.newSingleThreadExecutor();
try (Instance instance = instanceFactory.create()) {
    instance.init();
    instance.doStuff();
    while ((input = reader.readNext()) != null) {
        executor.execute(new Runnable() {
            @Override
            public void run() {
                instance.put(input);
            }
        });
    }
    executor.shutdown();
    executor.awaitTermination(1, TimeUnit.MINUTES);
}

注意：这是未经测试的代码。
您可能可以使用
如果instance.put（）
是线程安全的，则可以替换Executors.newSingleThreadExecutor（）与执行器。例如，newCachedThreadPool（）

InstanceFactory instanceFactory = new InstanceFactory();
ExecutorService executor = Executors.newSingleThreadExecutor();
try (Instance instance = instanceFactory.create()) {
    instance.init();
    instance.doStuff();
    while ((input = reader.readNext()) != null) {
        executor.execute(new Runnable() {
            @Override
            public void run() {
                instance.put(input);
            }
        });
    }
    executor.shutdown();
    executor.awaitTermination(1, TimeUnit.MINUTES);
}

注意：这是未经测试的代码。
您可能可以使用
如果instance.put（）
是线程安全的，则可以替换Executors.newSingleThreadExecutor（）与执行器。例如，newCachedThreadPool（）

InstanceFactory instanceFactory = new InstanceFactory();
ExecutorService executor = Executors.newSingleThreadExecutor();
try (Instance instance = instanceFactory.create()) {
    instance.init();
    instance.doStuff();
    while ((input = reader.readNext()) != null) {
        executor.execute(new Runnable() {
            @Override
            public void run() {
                instance.put(input);
            }
        });
    }
    executor.shutdown();
    executor.awaitTermination(1, TimeUnit.MINUTES);
}

注意：这是未经测试的代码。
您可能可以使用
如果instance.put（）
是线程安全的，则可以替换Executors.newSingleThreadExecutor（）与执行器。例如，newCachedThreadPool（）

InstanceFactory instanceFactory = new InstanceFactory();
ExecutorService executor = Executors.newSingleThreadExecutor();
try (Instance instance = instanceFactory.create()) {
    instance.init();
    instance.doStuff();
    while ((input = reader.readNext()) != null) {
        executor.execute(new Runnable() {
            @Override
            public void run() {
                instance.put(input);
            }
        });
    }
    executor.shutdown();
    executor.awaitTermination(1, TimeUnit.MINUTES);
}

注意：这是未经测试的代码。
执行器。newSingleThreadExecutor（）
只创建一个工作线程，因此您将有一个主线程+一个工作线程，具有post（）
任务的FIFO队列。如果您的post（）
方法是线程安全性，则应使用创建所需线程数的Executors.newCachedThreadPool（）

InstanceFactory instanceFactory = new InstanceFactory();
ExecutorService executor = Executors.newCachedThreadPool();
try (Instance instance = instanceFactory.create()) {
    instance.init();
    instance.doStuff();
    while ((input = reader.readNext()) != null) {
        executor.execute(new Runnable() {
            @Override
            public void run() {
                instance.put(input);
            }
        });
    }
} finally {
    executor.shutdown();
}

我建议您阅读一篇和一些关于执行器服务的文章。newSingleThreadExecutor（）只创建一个工作线程，因此您将有一个主线程+一个工作线程，其中包含一个post（）任务的FIFO队列。如果您的post（）
方法是线程安全性，则应使用创建所需线程数的Executors.newCachedThreadPool（）

InstanceFactory instanceFactory = new InstanceFactory();
ExecutorService executor = Executors.newCachedThreadPool();
try (Instance instance = instanceFactory.create()) {
    instance.init();
    instance.doStuff();
    while ((input = reader.readNext()) != null) {
        executor.execute(new Runnable() {
            @Override
            public void run() {
                instance.put(input);
            }
        });
    }
} finally {
    executor.shutdown();
}

我建议您阅读一篇和一些关于执行器服务的文章。newSingleThreadExecutor（）只创建一个工作线程，因此您将有一个主线程+一个工作线程，其中包含一个post（）任务的FIFO队列。如果您的post（）
方法是线程安全性，则应使用创建所需线程数的Executors.newCachedThreadPool（）

InstanceFactory instanceFactory = new InstanceFactory();
ExecutorService executor = Executors.newCachedThreadPool();
try (Instance instance = instanceFactory.create()) {
    instance.init();
    instance.doStuff();
    while ((input = reader.readNext()) != null) {
        executor.execute(new Runnable() {
            @Override
            public void run() {
                instance.put(input);
            }
        });
    }
} finally {
    executor.shutdown();
}

我建议您阅读一篇和一些关于执行器服务的文章。newSingleThreadExecutor（）只创建一个工作线程，因此您将有一个主线程+一个工作线程，其中包含一个post（）任务的FIFO队列。如果您的post（）
方法是线程安全性，则应使用创建所需线程数的Executors.newCachedThreadPool（）

InstanceFactory instanceFactory = new InstanceFactory();
ExecutorService executor = Executors.newCachedThreadPool();
try (Instance instance = instanceFactory.create()) {
    instance.init();
    instance.doStuff();
    while ((input = reader.readNext()) != null) {
        executor.execute(new Runnable() {
            @Override
            public void run() {
                instance.put(input);
            }
        });
    }
} finally {
    executor.shutdown();
}

我建议您阅读一篇关于执行器服务的文章和一些关于执行器服务的文章。实例。start（）
应该启动一个新线程，因为扩展了线程
或者实现了可运行
@AniketThakur Runnable。run（）不会启动新线程。@AniketThakur您说的“instance.start（）应该启动一个新线程，因为它扩展了线程或实现了Runnable”Runnable
没有start
方法。请提供一些上下文。put（）是一种需要很长时间才能完成的方法吗？你的意思是什么？我已经用代码更新了这个问题。instance.start（）
应该启动一个新线程，因为它是extends thread
或implements Runnable
。@AniketThakur Runnable.run（）不会启动一个新线程。@AniketThakur您说过“instance.start（）应该启动一个新线程，因为它扩展了thread或实现了Runnable”Runnable
没有start
方法。请提供一些上下文。put（）是一种需要很长时间才能完成的方法吗？你的意思是什么？我已经用代码更新了这个问题。instance.start（）
应该启动一个新线程，因为它是extends thread
或implements Runnable
。@AniketThakur Runnable.run（）不会启动一个新线程。@AniketThakur您说过“instance.start（）应该启动一个新线程，因为它扩展了thread或实现了Runnable”Runnable
没有start
方法。请提供一些上下文。put（）是一种需要很长时间才能完成的方法吗？你的意思是什么？我已经用代码更新了这个问题。instance.start（）
应该启动一个新线程，因为它是extends thread
或implements Runnable
。@AniketThakur Runnable.run（）不会启动一个新线程。@AniketThakur您说过“instance.start（）应该启动一个新线程，因为它扩展了thread或实现了Runnable”Runnable
没有start
方法。请提供一些上下文。put（）是一种需要很长时间才能完成的方法吗？你的意思是什么？我已经用代码更新了这个问题。你的回答在这个评论之后仍然有效吗？用newCachedThreadPool（）
替换newSingleThreadExecutor（）
有什么好处？@betanewSingleThreadExecutor
一次只运行一个任务（如果对instance.put（）
的多个并发调用可能会导致错误，这很有用）。您的答案仍然有效吗