Java   View all facts   Glossary   Help

object > thread

thread (lightweight process)
subject			fact

thread	is a synonym of lightweight process
	belongs to a thread group which places limitations on the thread to protect it from other threads
	can be blocked if it is waiting for or executing another function or thread that is blocked
	can be paused for a specific amount of time using the sleep method
	can run concurrently with 1 or more other threads
	has definition An object used in multithreaded software systems that represents a sequence of program execution
	has thread priority
	has example public class ThreadExample implements Runnable { private int counterNumber; // Identifies the thread private int counter; // How far the thread has executed private int limit; // Where counter will stop private long delay; // Pause in execution of thread in milisecs // Constructor private ThreadExample(int countTo, int number, long delay) { counter = 0; limit = countTo; counterNumber = number; this.delay = delay; } //The run method; when this finishes, the thread terminates public void run() { try { while (counter <= limit) { System.out.println("Counter " + counterNumber + " is now at " + counter++); Thread.sleep(delay); } } catch(InterruptedException e) {} } // The main method: Executed when the program is started public static void main(String[] args) //Create 3 threads and run them Thread firstThread = new Thread(new ThreadExample(5, 1, 66)); Thread secondThread = new Thread(new ThreadExample(5, 2, 45)); Thread thirdThread = new Thread(new ThreadExample(5, 3, 80)); firstThread.start(); secondThread.start(); thirdThread.start(); } }
	has purpose to enable a program to appear to be doing more than one thing at once
	has purpose to perform a job such as waiting for events or performing a time-consuming job that the program doesn't need to complete before going on
	is a subtopic of Threads
	is supported by many operating systems and programming languages
	is terminated when it has finished its job
	is a kind of object
	see also multithreading
	see also synchronization
	see also Thread class
	stops permanently when its run method returns
	to create you Create a class to contain the code that will control the thread. This can be made a subclass of Thread class, or else it can implement the interface Runnable. Write a method called run in your class. The run method will normally take a reasonably long time to execute - perhaps it waits for input in a loop. When the thread is started, this run method executes, concurrently with any other thread in the system. When the run method ends, the thread terminates Create an instance of Thread class, or your subclass of Thread class, and invoking the start operation on this instance. If you implemented the interface Runnable, you have to pass an instance of your class to the constructor of Thread class.
object	when an object is created the object's variables are set to default values the constructor of the object's superclass is invoked the object's initialization block is invoked the object's constructor is invoked
	object is not cloneable unless you implement the Cloneable interface and you override the clone method for the object's class
	when an object is created then the runtime system creates space for each of the object's instance variables
	when an object is not needed any longer the object's space is garbage collected
	can access all instance variables of all objects of its class
	can be encapsulated by providing accessor methods
	can be converted into a string using the toString method
	can be referred to without reference to the instance variables contained in it
	can be referred to by several different variables at the same time
	can communicate with every object to which it has access through its public interface
	can convert itself to a string representation using the toString method
	can model a real-world object or an abstract concept
	can notify other objects that a condition variable has changed
	can receive messages from objects in the same process objects in different processes objects on the same machine objects on different machines
	can represent any entity to which you can associate properties and behaviour
	can return its class using the getClass method
	can send messages to objects in the same process objects in different processes objects on the same machine objects on different machines
	can wait on 0 or more condition variables
	communicates with other objects by sending and receiving messages
	has example of creation String name = new String();
	has part public interface
	hides methods from other objects using the 'private' keyword
	inherits instance methods and instance variables from the class to which it belongs all that class's superclasses
	is distinct from every other object even if they contain the same data
	is created by declaring and initializing it such that it is created whenever execution enters a particular block, or, in the case of an instance variable, when an instance is created, for example: String aString = "some text"; or by declaring it and initializing it later using the new operator, for example: String aString; aString = new String("some text");
	shares every instance method of its class with the other instances of its class
	shares its implementation with other instances of its class
	shares one copy of each class variable of its class with the other instances of its class

Next object: uninitialized object    Up: object    Previous object: string