CODEWITHSUNDEEP
javamultithreading
Chetan
Chetan

Reputation: 125

About multi threading

How to kill the thread? ..... How to restart them again in multi threading?

Upvotes: 5

Views: 476

Answers (7)

Ravindra babu
Ravindra babu

Reputation: 38910

Regarding your first query on killing thread:

You can find more details about topic in below SE questions:

How to properly stop the Thread in Java?

How can I kill a thread? without using stop();

How to start/stop/restart a thread in Java?

Regarding your second query of re-starting thread, it's not possible in java.

You can find below details in documentation page

public void start()

Causes this thread to begin execution; the Java Virtual Machine calls the run method of this thread.

The result is that two threads are running concurrently: the current thread (which returns from the call to the start method) and the other thread (which executes its run method).

It is never legal to start a thread more than once. In particular, a thread may not be restarted once it has completed execution.

Instead of plain Threads, you can use advanced concurrent API for thread life cycle management. Have a look at this post for ExecutorService details :

How to properly use Java Executor?

Upvotes: 0

Jon Black
Jon Black

Reputation: 16559

i wrap my worker threads up in their own class and use a terminated property to kill the thread proc loop.

sorry i dont have a java version to hand right now but you should get the idea from this http://pastie.org/880516

using System.Threading; 

namespace LoaderDemo
{
    class ParserThread
    {
        private bool m_Terminated;
        private AutoResetEvent m_Signal;
        private string m_FilePath;
        ...

        public ParserThread(AutoResetEvent signal, string filePath)
        {
            m_Signal = signal; 
            m_FilePath = filePath;

            Thread thrd = new Thread(this.ThreadProc);
            thrd.Start(); 
        }

        public bool Terminated { 
            set { m_Terminated = value; } 
        }

        private Guid Parse(ref string s)
        {
            //parse the string s and return a populated Guid object
            Guid g = new Guid();

            // do stuff...

            return g;
        }

        private void ThreadProc()
        {
            TextReader tr = null;
            string line = null;
            int lines = 0;

            try
            {
                tr = new StreamReader(m_FilePath);
                while ((line = tr.ReadLine()) != null)
                {
                    if (m_Terminated) break;

                    Guid g = Parse(ref line);
                    m_GuidList.Add(g);
                    lines++;
                }

                m_Signal.Set(); //signal done

            }
            finally
            {
                tr.Close();
            }

        }

    }
}

Upvotes: 2

coobird
coobird

Reputation: 160954

The preferred way for a Thread to die is for the execution of the run method to go to completion:

Thread t = new Thread(new Runnable() {
  public void run() {
    // Do something...

    // Thread will end gracefully here.
  }
}

Once a thread gracefully dies in the example above, the Thread cannot be restarted. (Trying to call Thread.start on a thread that has already been started will cause an IllegalThreadStateException.)

In that case, one can make another instance of the thread and call start on that.

Probably a good place to get more information on threading would be Lesson: Concurrency from The Java Tutorials.

Upvotes: 3

malaverdiere
malaverdiere

Reputation: 1537

If you want to start, stop, restart threads at will, maybe using the Java 5 concurrency package would be a good idea. You can have an Executor that will do a bit of work, and when you need that bit of work to be done again, you can just re-schedule it to be done in the executor.

Upvotes: 1

avpx
avpx

Reputation: 1922

Since your post is tagged "Java," I have a good idea of what you are saying. Let's say you start a thread by doing:

Thread foo = new Thread(someRunnable);
foo.start();

Now that destroy and friends are deprecated, you need a way to kill the thread. Luckily for you, there has always been the concept of "interrupts." Simply change your runnable so that, on interrupt, it exits. Then call the thread's interrupt method.

foo.interrupt();

If you wrote your Runnable to handle this correctly, it will stop whatever it is doing and terminate.

Upvotes: 4

Ken Bloom
Ken Bloom

Reputation: 58770

The best way to kill a thread is to set up a flag for the thread to watch. Program the thread to exit when it sees the flag is set to true. There's no way to restart a killed thread.

Upvotes: 1

Will
Will

Reputation: 5537

Thread.stop() kills a thread, but you definitely don't want to do this (see the API documentation for an explanation why). Thread.interrupt() sends an asynchronous notification to a thread, so that it can shut itself gracefully.

For a comprehensive text on Java multithreading, I recommend B. Goetz, Java Concurrency in Practice, Addison-Wesley Professional.

Upvotes: 3

Related Questions