Java中单个类的线程减少

Question

I have gotten my code into a state where I am creating a couple of threads and then inside those threads I use a library framework which spawns some additional threads over the life span of my application.

I have no control over how many threads are spawned inside the library framework, but I know they exist because I can see them in the eclipse debugger, I have kept the threads I use outside the library framework to a minimum, because I really don't want a multithreaded application, but sometimes you have too.

Now I am at the point where I need to do things with sockets and I/O, both of which are inherently hard to deal with in a multithreaded environment and while I am going to make my program thread safe i'd rather not get into the situation in the first place, or at least minimize the occurrences, the classes I am attempting to reduce multithreading in aren't time sensitive and i'd like them to complete "when they get the time". As it happens the lazy work is all in the same class definition but due to reasons, the class is instantiated a hell of a lot.

I was wondering if it was possible to make single type classes use only one thread when instantiated from multiple threads, and how?

I imagine the only way to achieve this would be to create a separate thread specifically for handling and processing of a instances of single class type.

Or do I just have to think of a new way to structure my code?

EDIT: included an example of my applications architecture;

public class Example {
    public ArrayList<ThreadTypeA> threads = new ArrayList<ThreadTypeA>();
    public static void main(String[] args) {
        threads.add(new ThreadTypeA());
        // left out how dataObj gets to ThreadTypeB for brevity 
        dataObj data = new dataObj(events);
    }
}

 public ThreadTypeA {
     public ArrayList<ThreadTypeB> newThreads = new ArrayList<ThreadTypeB>();
     public Thread thread = new Thread(this, "");
 }

 public ThreadTypeB {
     // left out how dataObj gets to ThreadTypeB for brevity 
     public libObj libObj = new Library(dataObj);
 }

 public Library {
     public Thread thread = new Thread(this, "");
     @Override
     public void editMe(dataObj) {
         dataObj.callBack();
     }
 }

 public dataObj(events) {
      public void callMe() {
          for (Event event: events) {
              event.callMe();
          }
     }
 }

there are a number of different events that can be called, ranging from writing to files making sql queries, sending emails and using proprietary ethernet-serial comms. I wish all events to run on the same thread, sequentially.

Answer 1

Rather than having Threads, consider having Callable or Runnables. These are objects which represent the work that is to be done. Your code can pass these to a thread pool for execution - you'll get a Future. If you care about the answer, you'll call get on the future and your code will wait for the execution to complete. If it's a fire-and-forget then you can be assured it's queued and will get done in good time.

Generally it makes more sense to divorce your execution code from the threads that run it to allow patterns like this.

Answer 2

To restrict thread resources use a limited thread pool:

ExecutorService executor = Executors.newFixedThreadPool(4);
for (int i = 0; i < 100; ++i) {
    executor.execute(new Runnable() { ... });
}
executor.shutdown();

Also the reuse of threads of such a pool is said to be faster.

It might be a far hope that the library does a similar thing, and maybe even has the thread pool size configurable.