How to call a method with a separate thread in Java?
This worked perfectly for what I was doing. Needed to run a webservice and updating a progress bar concurrently using the observer pattern.
Do we need to explicitly terminate the thread? Isn’t there a risk of creating a memory leak by not explicitly terminating the thread? Or does the thread terminate when it’s done with run() ?
Create a class that implements the Runnable interface. Put the code you want to run in the run() method — that’s the method that you must write to comply to the Runnable interface. In your «main» thread, create a new Thread class, passing the constructor an instance of your Runnable , then call start() on it. start tells the JVM to do the magic to create a new thread, and then call your run method in that new thread.
public class MyRunnable implements Runnable < private int var; public MyRunnable(int var) < this.var = var; >public void run() < // code in the other thread, can reference "var" variable >> public class MainThreadClass < public static void main(String args[]) < MyRunnable myRunnable = new MyRunnable(10); Thread t = new Thread(myRunnable) t.start(); >> Take a look at Java’s concurrency tutorial to get started.
If your method is going to be called frequently, then it may not be worth creating a new thread each time, as this is an expensive operation. It would probably be best to use a thread pool of some sort. Have a look at Future , Callable , Executor classes in the java.util.concurrent package.
Processes and Threads
In concurrent programming, there are two basic units of execution: processes and threads. In the Java programming language, concurrent programming is mostly concerned with threads. However, processes are also important.
A computer system normally has many active processes and threads. This is true even in systems that only have a single execution core, and thus only have one thread actually executing at any given moment. Processing time for a single core is shared among processes and threads through an OS feature called time slicing.
It’s becoming more and more common for computer systems to have multiple processors or processors with multiple execution cores. This greatly enhances a system’s capacity for concurrent execution of processes and threads but concurrency is possible even on simple systems, without multiple processors or execution cores.
Processes
A process has a self-contained execution environment. A process generally has a complete, private set of basic run-time resources; in particular, each process has its own memory space.
Processes are often seen as synonymous with programs or applications. However, what the user sees as a single application may in fact be a set of cooperating processes. To facilitate communication between processes, most operating systems support Inter Process Communication (IPC) resources, such as pipes and sockets. IPC is used not just for communication between processes on the same system, but processes on different systems.
Most implementations of the Java virtual machine run as a single process. A Java application can create additional processes using a ProcessBuilder object. Multiprocess applications are beyond the scope of this lesson.
Threads
Threads are sometimes called lightweight processes. Both processes and threads provide an execution environment, but creating a new thread requires fewer resources than creating a new process.
Threads exist within a process every process has at least one. Threads share the process’s resources, including memory and open files. This makes for efficient, but potentially problematic, communication.
Multithreaded execution is an essential feature of the Java platform. Every application has at least one thread or several, if you count «system» threads that do things like memory management and signal handling. But from the application programmer’s point of view, you start with just one thread, called the main thread. This thread has the ability to create additional threads, as we’ll demonstrate in the next section.