Java线程学习

Java多线程总结的经典博文   http://lavasoft.blog.51cto.com/62575/27069

将一个类变为一个可执行的线程类有两个办法：

1、实现Runable接口

public class LearnThread implements Runnable{
    
    private String console;
    
    public LearnThread(String console){
        this.console = console;
    }

    /* (non-Javadoc)
     * @see java.lang.Runnable#run()
     */
    @Override
    public void run() {
        for(int i = 0 ; i<10 ; i++){
            System.out.println(console + " : "+i);
        }
    }

}

需要启动该线程的时候：

LearnThread learnThread1 = new LearnThread("console1");
Thread thread1 = new Thread(learnThread1);
thread1.start();

2、继承Thread类

/不建议使用此方法定义线程，因为采用继承Thread的方式定义线程后，你不能在继承其他的类了，导致程序的可扩展性大大降低。
public class LearnThread extends Thread{
    
    private String console;
    
    public LearnThread(String console){
        this.console = console;
    }

    /* (non-Javadoc) 重写run()方法 JVM会自动调用该方法
     */
    @Override
    public void run() {
        for(int i = 0 ; i<10 ; i++){
            System.out.println(console + " : "+i);
        }
    }
    
    //重载（Overload）run()方法 和普通的方法一样，并不会在该线程的start()方法被调用后被JVM自动运行
    public void run(String t){
        System.out.println("test");
    }

}

线程的方法（Method）、属性（Property）

 

1）优先级（priority）

 

每个类都有自己的优先级，一般property用1-10的整数表示，默认优先级是5，优先级最高是10；优先级高的线程并不一定比优先级低的线程执行的机会高，只是执行的机率高；默认一个线程的优先级和创建他的线程优先级相同；

 

2）Thread.sleep()/sleep(long millis)

 

当前线程睡眠/millis的时间（millis指定睡眠时间是其最小的不执行时间，因为sleep(millis)休眠到达后，无法保证会被JVM立即调度）；sleep()是一个静态方法(static method) ，所以他不会停止其他的线程也处于休眠状态；线程sleep()时不会失去拥有的对象锁。 作用：保持对象锁，让出CPU，调用目的是不让当前线程独自霸占该进程所获取的CPU资源，以留一定的时间给其他线程执行的机会；

 

3）Thread.yield()

 

  让出CPU的使用权，给其他线程执行机会、让同等优先权的线程运行（但并不保证当前线程会被JVM再次调度、使该线程重新进入Running状态），如果没有同等优先权的线程，那么yield()方法将不会起作用。

 

4）thread.join()

 

 使用该方法的线程会在此之间执行完毕后再往下继续执行。

 

5）object.wait()

 

  当一个线程执行到wait()方法时，他就进入到一个和该对象相关的等待池(Waiting Pool)中，同时失去了对象的机锁—暂时的，wait后还要返还对象锁。当前线程必须拥有当前对象的锁，如果当前线程不是此锁的拥有者，会抛出IllegalMonitorStateException异常,所以wait()必须在synchronized block中调用。

 

6）object.notify()/notifyAll()

 

  唤醒在当前对象等待池中等待的第一个线程/所有线程。notify()/notifyAll()也必须拥有相同对象锁，否则也会抛出IllegalMonitorStateException异常。

 

7）Synchronizing Block

 

 Synchronized Block/方法控制对类成员变量的访问；Java中的每一个对象都有唯一的一个内置的锁，每个Synchronized Block/方法只有持有调用该方法被锁定对象的锁才可以访问，否则所属线程阻塞；机锁具有独占性、一旦被一个Thread持有，其他的Thread就不能再拥有（不能访问其他同步方法），方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行状态。

Java中线程的状态有，new(新建状态) ， block（缺少其他资源） ， wait（只缺少cpu） ， running（正在运行） ， finish（结束）。

package com.unique.jointrent.util;

import java.util.ArrayList;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.unique.jointrent.service.UserService;

public class JMSTest implements Runnable {

    private Foo foo = new Foo(100); 

    public static void main(String[] args) { 
        JMSTest r = new JMSTest(); 
        Thread ta = new Thread(r, "Thread-A"); 
        Thread tb = new Thread(r, "Thread-B"); 
        ta.start(); 
        tb.start(); 
    } 

    public void run() { 
        for (int i = 0; i < 30; i++) { 
            this.fix(30); 
            try { 
                Thread.sleep(1); 
            } catch (InterruptedException e) { 
                e.printStackTrace(); 
            } 
            System.out.println(Thread.currentThread().getName() + " : 当前foo对象的x值= " + foo.getX()); 
        } 
    } 

    public void fix(int y) { 
        foo.sub(); 
    } 
}

执行结果：

Thread-B : 当前foo对象的x值= 40

Thread-A : 当前foo对象的x值= 40

Thread-B : 当前foo对象的x值= -20

Thread-A : 当前foo对象的x值= -50

Thread-B : 当前foo对象的x值= -80

Thread-A : 当前foo对象的x值= -80

Thread-B : 当前foo对象的x值= -140

Thread-A : 当前foo对象的x值= -140

Thread-B : 当前foo对象的x值= -200

Thread-A : 当前foo对象的x值= -200

Thread-A : 当前foo对象的x值= -260

Thread-B : 当前foo对象的x值= -260

...

上述执行结果明显不正确。

解决方法为使用synchronized关键字。

package com.unique.jointrent.util;

public class Foo {

    private int x;
    
    public Foo(int x){
        this.x = x;
    }
    
    public int getX(){
        return x;
    }
    
    public void sub(){
        synchronized (this){
            this.x = this.x-30;   
        }
    }
    
}
或者将方法设为同步
public synchronized void sub(){
        this.x = this.x-30;   
    }

关于锁和同步，有以下几个要点：

1）、只能同步方法，而不能同步变量和类；

2）、每个对象只有一个锁；当提到同步时，应该清楚在什么上同步？也就是说，在哪个对象上同步？

3）、不必同步类中所有的方法，类可以同时拥有同步和非同步方法。

4）、如果两个线程要执行一个类中的synchronized方法，并且两个线程使用相同的实例来调用方法，那么一次只能有一个线程能够执行方法，另一个需要等待，直到锁被释放。也就是说：如果一个线程在对象上获得一个锁，就没有任何其他线程可以进入（该对象的）类中的任何一个同步方法。

5）、如果线程拥有同步和非同步方法，则非同步方法可以被多个线程自由访问而不受锁的限制。

6）、线程睡眠时，它所持的任何锁都不会释放。

7）、线程可以获得多个锁。比如，在一个对象的同步方法里面调用另外一个对象的同步方法，则获取了两个对象的同步锁。

8）、同步损害并发性，应该尽可能缩小同步范围。同步不但可以同步整个方法，还可以同步方法中一部分代码块。

9）、在使用同步代码块时候，应该指定在哪个对象上同步，也就是说要获取哪个对象的锁。