Java线程学习

Java多线程总结的经典博文 /article/4121322.html

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

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）、在使用同步代码块时候，应该指定在哪个对象上同步，也就是说要获取哪个对象的锁。