java多线程编程

java多线程编程(zz)
线程的调度
1.调整线程优先级：Java线程有优先级，优先级高的线程会获得较多的运行机会。
Java线程的优先级用整数表示，取值范围是1~10，Thread类有以下三个静态常量：
static int MAX_PRIORITY
          线程可以具有的最高优先级，取值为10。
static int MIN_PRIORITY
          线程可以具有的最低优先级，取值为1。
static int NORM_PRIORITY
          分配给线程的默认优先级，取值为5。
Thread类的setPriority()和getPriority()方法分别用来设置和获取线程的优先级。

每个线程都有默认的优先级。主线程的默认优先级为Thread.NORM_PRIORITY。
线程的优先级有继承关系，比如A线程中创建了B线程，那么B将和A具有相同的优先级。
JVM提供了10个线程优先级，但与常见的操作系统都不能很好的映射。如果希望程序能移植到各个操作系统中，应该仅仅使用Thread类有以下三个静态常量作为优先级，这样能保证同样的优先级采用了同
样的调度方式。(线程优先级也不会一定保证线程调度的顺序！)
2.线程睡眠：Thread.sleep(long millis)方法，使线程转到阻塞状态。millis参数设定睡眠的时间，以毫秒为单位。当睡眠结束后，就转为就绪（Runnable）状态。sleep()平台移植性好。
3.线程等待：Object类中的wait()方法，导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 唤醒方法。这个两个唤醒方法也是Object类中的方法，行为等价于调用 wait(0) 一样。wait()方法被调用时会解除锁定，但是我们能使用它的地方只是在一个同步的方法或代码块内。
4.线程唤醒：Object类中的notify()方法，唤醒在此对象监视器上等待的单个线程。如果所有线程都在此对象上等待，则会选择唤醒其中一个线程。选择是任意性的，并在对实现做出决定时发生。线程通过调用其中一个 wait 方法，在对象的监视器上等待。 直到当前的线程放弃此对象上的锁定，才能继续执行被唤醒的线程。被唤醒的线程将以常规方式与在该对象上主动同步的其他所有线程进行竞争；例如，唤醒的线程在作为锁定此对象的下一个线程方面没有可靠的特权或劣势。类似的方法还有一个notifyAll()，唤醒在此对象监视器上等待的所有线程。
5.线程让步：Thread.yield() 方法，暂停当前正在执行的线程对象，把执行机会让给相同或者更高优先级的线程。
6.线程加入：join()方法，等待其他线程终止。在当前线程中调用另一个线程的join()方法，则当前线程转入阻塞状态，直到另一个进程运行结束，当前线程再由阻塞转为就绪状态。

synchronized 关键字
每个对象都有一个标志锁。当对象的一个线程访问了对象的某个synchronized数据（包括函数）时，这个对象就将被“上锁”，所以被声明为synchronized的数据（包括函数）都不能被调用（因为当前线程取走了对象的“锁标志”）。只有当前线程访问完它要访问的synchronized数据，释放“锁标志”后，同一个对象的其它线程才能访问synchronized数据。
每个class也有一个“锁标志”。对于synchronized static数据（包括函数）可以在整个class下进行锁定，避免static数据的同时访问。
也可以使用synchronized　block来缩小同步的范围，提高效率。语法为：synchronized(reference){ do this }。对大括号内的语句进行同步控制时，会取走当前对象的“锁标志”，即对当前对象“上锁”，不让当前对象下的其它线程执行当前对象的其它synchronized数据。

到目前为止，我们看到的示例都只是以非常简单的方式来利用线程。只有最小的数据流，而且不会出现两个线程访问同一个对象的情况。但是，在大多数有用的程序中，线程之间通常有信息流。试考虑一个金融应用程序，它有一个 Account 对象，如下例中所示：
一个银行中的多项活动
public class Account { 
　　String holderName; 
　　float amount; 
　　public Account(String name, float amt) { 
　　holderName = name; 
　　amount = amt; 
　　}
public void deposit(float amt) { 
　　amount += amt; 
　　}
public void withdraw(float amt) { 
　　amount -= amt; 
　　}
public float checkBalance() { 
　　return amount; 
　　}
}
在此代码样例中潜伏着一个错误。如果此类用于单线程应用程序，不会有任何问题。但是，在多线程应用程序的情况中，不同的线程就有可能同时访问同一个 Account 对象，比如说一个联合帐户的所有者在不同的 ATM 上同时进行访问。在这种情况下，存入和支出就可能以这样的方式发生：一个事务被另一个事务覆盖。这种情况将是灾难性的。但是，Java 编程语言提供了一种简单的机制来防止发生这种覆盖。每个对象在运行时都有一个关联的锁。这个锁可通过为方法添加关键字 synchronized 来获得。这样，修订过的 Account 对象（如下所示）将不会遭受像数据损坏这样的错误：
对一个银行中的多项活动进行同步处理
public class Account { 
　　String holderName; 
　　float amount; 
　　public Account(String name, float amt) { 
　　holderName = name; 
　　amount = amt; 
　　}
public synchronized void deposit(float amt) { 
　　amount += amt; 
　　}
public synchronized void withdraw(float amt) { 
　　amount -= amt; 
　　}
public float checkBalance() { 
　　return amount; 
　　}
}
deposit() 和 withdraw() 函数都需要这个锁来进行操作，所以当一个函数运行时，另一个函数就被阻塞。请注意， checkBalance() 未作更改，它严格是一个读函数。因为 checkBalance() 未作同步处理，所以任何其他方法都不会阻塞它，它也不会阻塞任何其他方法，不管那些方法是否进行了同步处理。

通过调用Thread类的start()方法来启动一个线程，这时此线程是处于就绪状态，并没有运行。然后通过此Thread类调用方法run()来完成其运行操作的，这里方法run()称为线程体，它包含了要执行的这个线程的内容，Run方法运行结束，此线程终止，而CPU再运行其它线程。 
    而如果直接用Run方法，这只是调用一个方法而已，程序中依然只有主线程--这一个线程，其程序执行路径还是只有一条，这样就没有达到写线程的目的。 
    记住：线程就是为了更好地利用CPU，提高程序运行速率的！ 
    public class TestThread1{ 
        public static void main(String[] args){ 
            Runner1 r=new Runner1(); 
            //r.run();//这是方法调用，而不是开启一个线程 
            Thread t=new Thread(r);//调用了Thread(Runnable target)方法。且父类对象变量指向子类对象。 
            t.start(); 
            for(int i=0;i<100;i++){ 
                System.out.println("进入Main Thread运行状态"); 
                System.out.println(i); 
            } 
        } 
    } 
    class Runner1 implements Runnable{ //实现了这个接口，jdk就知道这个类是一个线程 
        public void run(){ 
            for(int i=0;i<100;i++){ 
                System.out.println("进入Runner1运行状态"); 
                System.out.println(i); 
            } 
        } 
    }

注意：

Runnable接口分析

Java中实现多线程有两种途径:继承Thread类或者实现Runnable接口.
Runnable接口非常简单,就定义了一个方法run(),继承Runnable并实现这个
方法就可以实现多线程了,但是这个run()方法不能自己调用,必须由系统来调用,否则就和别的方法没有什么区别了.
先给一个简单的例子:
public class MultiThread implements Runnable{
public static void main(String[] args){
     for(int i=0;i<10;i++){
        new Thread(new MultiThread()).start();//correct
                 //new Thread(new MultiThread()).run 1
   //new MultiThread().run()       2 
     }
}
public void run(){    
     System.out.println(Thread.currentThread().getName());
}
}
运行后应该启动了10个新的线程,加上主线程一共11个线程,应该输出是Thread-1知道10.
这里要注意启动线程的方式是调用了Thread的start()方法,而不是run方法,如果
用注释里的1或者2输入都是10个main,因为这个时候run()方法还原了,和普通方法一样了.
我们也可以得出一个结论:所有的线程在运行时都是一个Thread实例,虽然可以不用继承Thread
实现多线程,但是最终还是Thread的一个实例.