J2me线程详解

　　　activeCount()
　　　currentThread()
　　　getPriority()
　　　isAlive()
　　　join()
　　　run()
　　　setPriority()
　　　sleep()
　　　start()
　　　yield()

public class DoSomething implements Runnable {
public void run(){
// here is where you do something

}
}

...
DoSomething doIt = new DoSomething();
Thread myThread = new Thread( doIt );
myThread.start();
...

public class DoAnotherThing extends Thread {
public void run(){
// here is where you do something

}
}

...
DoAnotherThing doIt = new DoAnotherThing();
doIt.start();
...

public void run(){
boolean quit = false;

while( !quit ){
// repeat some action


quit = .... // decide if it should quit

}
}

public class ThreadedDoIt implements Runnable {
private SomeClass state;
public ThreadedDoIt( SomeClass initState ){
state = initState;
new Thread( this ).start();
}
public void run(){
// do something based on "state" field

}
}

public class MyThread implements Runnable {
private boolean quit = false;

public void run(){
while( !quit ){
// do something

}
}

public void quit(){
quit = true;
}
}

public class AnotherThread implements Runnable {
private Thread mostRecent = null;
public Thread restart(){
mostRecent = new Thread( this );
mostRecent.start();
}
public void run(){
Thread thisThread = Thread.currentThread();
while( mostRecent == thisThread ){
// do something

}
}
public void stopAll(){
mostRecent = null;
}
}

...
while( mostRecent == thisThread ){
doLengthyOperation1();
if( mostRecent != thisThread ) break;
doLengthyOperation2();
if( mostRecent != thisThread ) break;
doLengthyOperation3();
}
...

public void run(){
RecordStore rs = null;

try {
rs = RecordStore.openRecordStore("myrs", true );
// do something with the record store...

}
finally {
if( rs != null ){
try {
rs.close();
}
catch( RecordStoreException e ){}
}
}
}

...
MyThread other = .... // 另外一个正在执行的线程

other.quit(); // 要求它退出

other.join(); // 等待直到other线程退出

...

public void appendTime( StringBuffer buf ){
synchronized( buf ){
buf.append( "Current time is: " );
buf.append( System.currentTimeMillis() );
}
}

public class Counter {
private int counter;

public int increment(){
synchronized( this ){
return ++counter;
}
}

public int decrement(){
synchronized( this ){
if( --counter < 0 ){
counter = 0;
}

return counter;
}
}
}

public class Counter {
private int counter;

public synchronized int increment(){
return ++counter;
}

public synchronized int decrement(){
if( --counter < 0 ){
counter = 0;
}

return counter;
}
}

public class SomeClass {
public static synchronized void someMethod(){
// do something

}
}

public class SomeClass {
public static void someMethod(){
synchronized( SomeClass.getClass() ){
// do something

}
}
}

public void appendTime( StringBuffer buf ){
synchronized( buf ){
buf.append( "Current time is: " );
buf.append( System.currentTimeMillis() );
}
}

public synchronized void appendTime(
StringBuffer buf ){
buf.append( "Current time is " );
buf.append( System.currentTimeMillis() );
}

public void appendTime( StringBuffer buf ){
synchronized( this ){
buf.append( "Current time is " );
buf.append( System.currentTimeMillis() );
}
}

import java.util.Vector;

public class Worker implements Runnable {
private boolean quit = false;
private Vector queue = new Vector();
private Thread thread;

public Worker(){
new Thread( this ).start();
}

public void run(){
Object o;

while( !quit ){ // busy wait!

o = null;

synchronized( queue ){
if( queue.size() > 0 ){
o = queue.elementAt( 0 );
queue.removeElementAt( 0 );
}
}

if( o != null ){
// do something

}
}
}

public boolean addToQueue( Object o ){
if( !quit ){
queue.addElement( o );
return true;
}

return false;
}

public void quit(){
quit = true;
}
}

...
Object obj = .... // some object to use as a lock


synchronized( obj ){
// here is where you'd check obj's state


try {
obj.wait();
}
catch( InterruptedException e ){
}
}
...

...
Object obj = .... // same object used as lock!


synchronized( obj ){
obj.notify(); // or notifyAll

}
...

import java.util.Vector;

public class Worker implements Runnable {
private boolean quit = false;
private Vector queue = new Vector();

public Worker(){
new Thread( this ).start();
}

public void run(){
Object o;

while( !quit ){
o = null;

synchronized( queue ){
if( queue.size() > 0 ){
o = queue.elementAt( 0 );
queue.removeElementAt( 0 );
} else {
try {
queue.wait();
}
catch( InterruptedException e ){
}
}
}

if( o != null ){
// do something

}
}
}

public boolean addToQueue( Object o ){
synchronized( queue ){
if( !quit ){
queue.addElement( o );
queue.notify();
return true;
}

return false;
}
}

public void quit(){
synchronized( queue ){
quit = true;
queue.notify();
}
}
}

package javax.wireless.messaging;

public interface MessageListener {
void notifyIncomingMessage(
MessageConnection conn );
}

import java.io.IOException;
import java.util.Vector;
import javax.wireless.messaging.*;

// A message receiver waits for messages to arrive

// on a message connection and then uses a separate

// thread to receive the actual message.


public class MessageQueuer
implements Runnable, MessageListener {

// A data structure representing either a

// connection-message pair (if a message was read)

// or a connection-exception pair (if an error

// occurred during the reading).


public static class Entry {
MessageConnection connection;
Message message;
IOException exception;
}

private Vector incoming = new Vector();
private Vector outgoing;
private boolean stop;

// Pass the outgoing vector into the constructor.


public MessageQueuer( Vector outgoing ){
this.outgoing = outgoing;
new Thread( this ).start();
}

// Called whenever a message arrives for the 

// given connection. Queues the connection object 

// and wakes up the thread to actually receive 

// the message.


public void notifyIncomingMessage( 
MessageConnection conn ){
if( !stop ){
synchronized( incoming ){
incoming.addElement( conn );
incoming.notify();
}
}
}

// Waits for incoming connection objects to be 

// queued. When one arrives, pulls it off the queue 

// and receives the messags. Queues the resulting

// connection-message pair on the outgoing

// queue and wakes anyone listening to the queue.


public void run(){
while( !stop || !incoming.isEmpty() ){
MessageConnection conn = null;

synchronized( incoming ){
while( !stop && incoming.isEmpty() ){
try {
incoming.wait();
}
catch( InterruptedException e ){
}
}

if( !incoming.isEmpty() ){
conn = (MessageConnection) 
incoming.elementAt( 0 );
incoming.removeElementAt( 0 );
}
}

if( conn == null ) continue;

Entry entry = new Entry();
entry.connection = conn;

try {
entry.message = conn.receive();
}
catch( IOException e ){
entry.exception = e;
}

synchronized( outgoing ){
outgoing.addElement( entry );
outgoing.notify();
}
}
}

// Stops the processing of messages.


public void stop(){
synchronized( incoming ){
stop = true;
incoming.notify();
}
}
}

...
Vector receiver = new Vector();
MessageQueuer queuer = new MessageQueuer( receivef );
MessageConnection conn1 = ... // a server connection

MessageConnection conn2 = ... // another connection

conn1.setMessageListener( queuer );
conn2.setMessageListener( queuer );
...

...
Vector receiver = .... // the receiving queue

boolean quit = false;

while( !quit ){
MessageQueuer.Entry entry;

synchronized( receiver ){
while( receiver.isEmpty() ){
try {
receiver.wait();
}
catch( InterruptedException e ){
}
}

entry = (MessageQueuer.Entry)
receiver.elementAt( 0 );
receiver.removeElementAt( 0 );
}

if( entry.message != null ){
// handle entry.message here

} else {
// handle entry.exception here

}

entry = null;
}
...