难以理解Java线程

Question

I'm sorry in advance, I learned about multiprocessing from python and I'm having a bit of trouble understanding Java's approach. In python, I can say I want a pool of 4 processes and then send a bunch of work to my program and it'll work on 4 items at a time. I realized, with Java, I need to use threads to achieve this same task and it seems to be working really really well so far.

But..I unlike in python, my cpu(s) aren't getting 100% utilization(they are about 70-80%) and I suspect its the way I'm creating threads(code is the same between python/java and proceses are independent). In Java, I'm not sure how to create one thread so I create a thread for every item in a list I want to process, like this:

    for (int i = 0; i < 500; i++) {
        Runnable task = new MyRunnable(10000000L + i);
        Thread worker = new Thread(task);
        // We can set the name of the thread
        worker.setName(String.valueOf(i));
        // Start the thread, never call method run() direct
        worker.start();
        // Remember the thread for later usage
        threads.add(worker);
    }

I took it from here . My question is this the correct way to launch threads or is there a way to have java itself manage the number of threads so its optimal? I, like everyone I guess, want my code to run as fast as possible and I'm trying to understand how to tell and resolve any issues that maybe arising from too many threads being created. This is not a major issue, just curious to how it works under the java hood.

Thanks!

Answer 1

You use an Executor , the implementation of which handles a pool of threads, decides how many, and so forth. See the Java tutorial for lots of examples.

In general, bare threads aren't used in Java except for very simple things. Instead, there will be some higher-level API that receives your Runnable or Task and knows what to do.

Answer 2

Take a look at the Java Executor API. See this article , for example.

Although creating Threads is much 'cheaper' than it used to be, creating large numbers of threads (one per runnable as in your example) isn't the way to go - there's still an overhead in creating them, and you'll end up with too much context switching.

The Executor API allows you to create various types of thread pool for executing Runnable tasks, so you can reuse threads, flexibly manage the number that are created, and avoid the overhead of thread-per-runnable.

The Java threading model and the Python threading model (not multiprocessing) are really quite similar, incidentally. There isn't a Global Interpreter Lock as in Python, so there's usually less need to fork off multiple processes.

Answer 3

Thread is a "low level" API.

Depending on what you want to do, and the version of java you use, their is better solution. If you use Java 7, and if your task allow it, you can use the fork/join framework : http://docs.oracle.com/javase/tutorial/essential/concurrency/forkjoin.html

However, take a look at the java concurrency tutorial : http://docs.oracle.com/javase/tutorial/essential/concurrency/executors.html