一个简单的线程例子

SimpleThreads程序有两个线程组成，第一个是主线程，它从创建了一个线程并等待它执行完成。如果MessageLoop线程执行了太长时间，主线程将会将其中断。
MessageLoop现场将会打印一系列的信息。如果中断在它打印完所有信息前发生，它将会打印一个特定的消息并退出。
java 代码

    public class SimpleThreads {  

// Display a message, preceded by 
// the name of the current thread 
static void threadMessage(String message) {  
            String threadName =  
                Thread.currentThread().getName();  
            System.out.format("%s: %s%n",  
                              threadName,  
                              message);  
        }  

private static class MessageLoop 
implements Runnable {  
public void run() {  
                String importantInfo[] = {  
"Mares eat oats",  
"Does eat oats",  
"Little lambs eat ivy",  
"A kid will eat ivy too"  
                };  
try {  
for (int i = 0;  
                         i < importantInfo.length;  
                         i++) {  
// Pause for 4 seconds 
                        Thread.sleep(4000);  
// Print a message 
                        threadMessage(importantInfo[i]);  
                    }  
                } catch (InterruptedException e) {  
                    threadMessage("I wasn't done!");  
                }  
            }  
        }  

public static void main(String args[])  
throws InterruptedException {  

// Delay, in milliseconds before 
// we interrupt MessageLoop 
// thread (default one hour). 
long patience = 1000 * 60 * 60;  

// If command line argument 
// present, gives patience 
// in seconds. 
if (args.length > 0) {  
try {  
                    patience = Long.parseLong(args[0]) * 1000;  
                } catch (NumberFormatException e) {  
                    System.err.println("Argument must be an integer.");  
                    System.exit(1);  
                }  
            }  

            threadMessage("Starting MessageLoop thread");  
long startTime = System.currentTimeMillis();  
            Thread t = new Thread(new MessageLoop());  
            t.start();  

            threadMessage("Waiting for MessageLoop thread to finish");  
// loop until MessageLoop 
// thread exits 
while (t.isAlive()) {  
                threadMessage("Still waiting...");  
// Wait maximum of 1 second 
// for MessageLoop thread 
// to finish. 
                t.join(1000);  
if (((System.currentTimeMillis() - startTime) > patience)  
                      && t.isAlive()) {  
                    threadMessage("Tired of waiting!");  
                    t.interrupt();  
// Shouldn't be long now 
// -- wait indefinitely 
                    t.join();  
                }  
            }  
            threadMessage("Finally!");  
        }  
    }

Java编程语言提供两种同步方式：同步方法和同步语句。
同步方法：
要让一个方法成为同步方法，只需要在方法声明中加上synchronized关键字：

    public class SynchronizedCounter {  
private int c = 0;  

public synchronized void increment() {  
            c++;  
        }  

public synchronized void decrement() {  
            c--;  
        }  

public synchronized int value() {  
return c;  
        }  
    }

如果count是SynchronizedCounter类的实例，那么让这些方法成为同步方法有两个作用:
首先，相同对象上的同步方法的两次调用，它们要交替执行是不可能的。当一个线程正在执行对象的同步方法时，所有其他调用该对象同步方法的线程会被阻塞（挂起执行）,直到第一个线程处理完该对象。

其次，当一个同步方法退出时，它会自动跟该对象同步方法的任意后续调用建立起一种happens-before关系。这确保对象状态的改变对所有线程是可见的。

注意构造方法不能是同步的——构造方法加synchronized关键字会报语法错误。同步的构造方法没有意义，因为当这个对象被创建的时候，只有创建对象的线程能访问它。

警告：当创建的对象会被多个线程共享时必须非常小心，对象的引用不要过早“暴露”出去。比如，假设你要维护一个叫instances的List，它包含类的每一个实例对象。你可能会尝试在构造方法中加这样一行：

    instances.add(this);

死锁
死锁描述了这样一种情景，两个或多个线程永久阻塞，互相等待对方释放资源。下面是一个例子。

Alphone和Gaston是朋友，都很讲究礼节。礼节有一个严格的规矩，当你向一个朋友鞠躬时，你必须保持鞠躬的姿势，直到你的朋友有机会回鞠给你。不幸的是，这个规矩没有算上两个朋友相互同时鞠躬的可能。

下面的应用例子，DeadLock，模拟了这个可能性。

static class Friend {  
private final String name;  
public Friend(String name) {  
this.name = name;  
        }  
public String getName() {  
return this.name;  
        }  
public synchronized void bow(Friend bower) {  
            System.out.format("%s: %s"  
                + " has bowed to me!%n",  
this.name, bower.getName());  
            bower.bowBack(this);  
        }  
public synchronized void bowBack(Friend bower) {  
            System.out.format("%s: %s"  
                + " has bowed back to me!%n",  
this.name, bower.getName());  
        }  
    }  

public static void main(String[] args) {  
final Friend alphonse =  
new Friend("Alphonse");  
final Friend gaston =  
new Friend("Gaston");  
new Thread(new Runnable() {  
public void run() { alphonse.bow(gaston); }  
        }).start();  
new Thread(new Runnable() {  
public void run() { gaston.bow(alphonse); }  
        }).start();  
    }  
}

http://www.iteye.com/magazines/131-Java-Concurrency 原文链接
多线程单例实现：http://blog.csdn.net/shiyanming1223/article/details/6933420

秒客网

一个简单的线程例子

相关文章