java多线程基础篇（部分转载）

多线程：

一个多线程的实现可以继承Thread类，也可以实现Runnalble接口实现。

其实Thread类是实现Runnanble接口来的。

Runnable接口只定义了一个抽象方法run();

 

public interface Runnable
{

    public abstract void run();
}

1、继承Thread类建一个线程，重写run方法：

 

 

public class Thread1 extends Thread{
	
	private int i=0;
	@Override
	public void run() {	//线程运行
		for(int m=0; m<5; m++){
			try {
				sleep(1000);	//线程阻塞
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println("Thread1:"+(++i));
		}
		//线程出了for循环，线程终止
	}
}

 

 

public class ThreadMain {
	public static void main(String[] args) {
		Thread1 t1 = new Thread1();	//创建线程
		t1.start();	//线程就绪
	}
}

2、实现Runnable接口建线程，重写接口所有的方法：

 

 

public class Thread2 implements Runnable{

	private int i=0;
	
	public void run() {
		for(int m=0; m<5; m++){
			try {
				Thread.sleep(1000);	//线程阻塞
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println("Thread2:"+(++i));
		}
		//线程出了for循环，线程终止
	}

}

 

public class ThreadMain {
	public static void main(String[] args) {
		//Thread1 t1 = new Thread1();	//创建线程
		Runnable runnable = new Thread2();
		Thread t2 = new Thread(runnable);	//构造方法public Thread(Runnable runnable)
		//t1.start();	//线程就绪
		t2.start();
	}
}

t1和t2两个线程同时执行代码和执行结果：

 

 

public class ThreadMain {
	public static void main(String[] args) {
		Thread1 t1 = new Thread1();	//创建线程
		Runnable runnable = new Thread2();
		Thread t2 = new Thread(runnable);	//构造方法public Thread(Runnable runnable)
		t1.start();	//线程就绪
		t2.start();
	}
}

每次执行结果均不一样。

 

 

同步（锁）：线程的运行没有固定的规律，可以会存在两个线程同时访问同一个对象的统一资源，导致有问题（比如银行存款，两个人同时取钱，需要一个取完再一个，免得会导致金额不对）。这样可以采用锁的方式进行锁定。一个对象有一个锁，当访问到某个同步方法或者同步代码块的时候，这个对象的锁就被这个线程拿走了，其他线程就没有办法访问该对象的同步方法或代码块。需要该线程释放锁之后，其他线程方可访问。

注意一个对象有含锁的方法，也有不含锁的方法，阻塞同步只是对含锁的方法或代码块生效。

所以在定义锁的时候需要明确是对哪个对象锁定了。

 

一个线程的生命周期：创建线程——就绪——运行——阻塞——终止

 

线程的状态转换图（引用）：

 

 

1、新建状态（New）：新创建了一个线程对象。

2、就绪状态（Runnable）：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。

3、运行状态（Running）：就绪状态的线程获取了CPU，执行程序代码。

4、阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：

（一）、等待阻塞：运行的线程执行wait()方法，JVM会把该线程放入等待池中。

（二）、同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池中。

（三）、其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

5、死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

 

 

 

线程的调度：

1、调整线程优先级：Java线程有优先级，优先级高的线程会获得较多的运行机会。

 

2、线程睡眠：Thread.sleep(long millis)方法，使线程转到阻塞状态。millis参数设定睡眠的时间，以毫秒为单位。当睡眠结束后，就转为就绪（Runnable）状态。sleep()平台移植性好。

 

3、线程等待：Object类中的wait()方法，导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 唤醒方法。这个两个唤醒方法也是Object类中的方法，行为等价于调用 wait(0) 一样。

 

4、线程让步：Thread.yield() 方法，暂停当前正在执行的线程对象，把执行机会让给相同或者更高优先级的线程。

 

5、线程加入：join()方法，等待其他线程终止。在当前线程中调用另一个线程的join()方法，则当前线程转入阻塞状态，直到另一个进程运行结束，当前线程再由阻塞转为就绪状态。

 

6、线程唤醒：Object类中的notify()方法，唤醒在此对象监视器上等待的单个线程。如果所有线程都在此对象上等待，则会选择唤醒其中一个线程。选择是任意性的，并在对实现做出决定时发生。线程通过调用其中一个 wait 方法，在对象的监视器上等待。 直到当前的线程放弃此对象上的锁定，才能继续执行被唤醒的线程。被唤醒的线程将以常规方式与在该对象上主动同步的其他所有线程进行竞争；例如，唤醒的线程在作为锁定此对象的下一个线程方面没有可靠的特权或劣势。类似的方法还有一个notifyAll()，唤醒在此对象监视器上等待的所有线程。

 

注意：Thread中suspend()和resume()两个方法在JDK1.5中已经废除，不再介绍。因为有死锁倾向。

 

 

 

好文推荐：http://www.mamicode.com/info-detail-517008.html

 

 

//sleep,join,wait,notify/notify all/sychroniezd/yield
//sleep休眠线程指定时间，监控状态，休眠结束继续执行。让出cpu，不让出锁
//join线程加入。A.join();就是在当前线程先插入A线程，等待A线程执行完再执行当前线程。可以给线程执行指定顺序。
//wait/notify/notify all方法。生产者消费者模式
//wait和sleep的区别（wait多用于线程的交互，sleep多用于线程的暂停执行）
//sychronized(Class或者实例)
//yield
//Lock接口分别提供了读写锁，缓存(多个用户读，一个用户写)