线程学习——基础

一、简单概念

进程：通俗讲就是某个应用程序。比如你在电脑或手机上看电影（一个进程）、听音乐（另一个进程）等。

线程：进程中的一个个任务。比如听音乐的时候，手机里的程序要帮忙寻找歌词、发出声音等。

一个进程至少有一个线程。

二、线程的生命周期：

1、创建线程

2、进入就绪状态

3、运行

4、销毁，被 GC 回收

当然期间还有 阻塞 状态。

三、线程实现方式

1、继承 Thread 类

2、实现 Runnable 接口

两种方式都要重写 run( ) 方法。

启动都是调用 start( )  方法。

3、推荐使用实现接口的方式创建线程。因为 java 支持单继承，但是可是实现多个接口。

继承方式：

package thread;

public class ThreadExt extends Thread{
	public void run(){
		System.out.println(Thread.currentThread().getName() + "启动");
	}
}

实现接口方式：

package thread;

public class ThreadImpl implements Runnable {
	public void run(){
		System.out.println(Thread.currentThread().getName() + "启动");
	}
}

测试类：

package thread;

public class Test {
	public static void main(String[] args) {
        new ThreadExt().start();
        new Thread(new ThreadImpl()).start();
    }
}

四、相关方法

1、start( ) 方法

作用：启动线程

2、run( ) 方法

作用：定义线程要做的事

3、join( ) 方法

作用：调用该方法的线程对象强制运行，该线程强制运行期间，其他线程无法运行。

package thread;

public class YourThread implements Runnable {
	
	public void run(){
		for (int i = 0; i < 100; i++){
			System.out.println(Thread.currentThread().getName() + i + "运行中");
			
		}
	}
}

package thread;

public class ThreadTest {
	public static void main(String[] args) throws InterruptedException {
		
		
		Thread t = new Thread(new YourThread(), "xiao");
		t.start();
		t.join();
		new Thread(new YourThread(), "fa").start();
	}
}

如果把 t.join(); 这行注释掉，两个线程 “xiao” “ fa” 可能会交替运行。

如果加上 t.join(); 这行，必然是线程 “xiao” 先执行完毕，才执行线程 “fa”。

4、sleep( ) 方法

可以有参数——××毫秒

作用：调用该方法的线程将暂停运行一段时间，时间一到或者被唤醒，线程进入就绪状态。

5、yield( )  方法

作用：调用该方法的线程将暂停运行，进入就绪状态，可参与和其他线程抢占 CPU。

6、synchronized

这是一个关键字，用来给对象或方法或代码块加锁，保证同一时刻只有一个线程执行该代码块。

1、可以用来修饰代码块

package thread;

public class SyncTest implements Runnable {
	private int num = 100;

	public void run() {
		while (true) {
			synchronized (this) {
				System.out.println(Thread.currentThread().getName() + "卖出"
						+ num + "号");
				num--;
				Thread.yield();		//该行为了方便更容易出现模拟效果
				if(num < 0)
					break;
			}
		}
	}
}

2、修饰方法

package thread;

public class SyncMethod implements Runnable {
	private int num = 100;

	public void run() {
/*		for (int i = 0; i < 100; i++) {
			met();
		}
		*/
		while(true){
			met();
		}
	}

	private synchronized void met() {
		// TODO Auto-generated method stub
		if (num > 0) {
			System.out.println(Thread.currentThread().getName() + "卖出"
					+ num-- + "号");
		}
	}
}

以上两种方式的测试类：

package thread;

//两个卖票窗口，共卖100张票

public class Test {
	public static void main(String[] args) {
//		SyncTest t = new SyncTest();
		SyncMethod t = new SyncMethod(); 
		Thread t1 = new Thread(t, "A");
		Thread t2 = new Thread(t, "B");
		t1.start();
		t2.start();
    }
}

以下来自百科：

一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。
另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。

二、然而，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。

三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有
其它synchronized(this)同步代码块的访问将被阻塞。

四、第三个例子同样适用其它同步代码块，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分
的访问都被暂时阻塞。

五、以上规则对其它对象锁同样适用。

7、lock( ) 方法

具有与使用 synchronized 方法和语句所访问的隐式监视器锁相同的一些基本行为和语义，但功能更强大。

下面是与 synchronized 举的一样的例子。

1、锁代码块

package thread;

import java.util.concurrent.locks.ReentrantLock;

public class LockTest implements Runnable {
	private final ReentrantLock lock = new ReentrantLock();// 可重入锁
	int num = 100;

	public void run() {

		while (true) {
			lock.lock();
			try {
				if (num > 0) {
					System.out.println(Thread.currentThread().getName() + "卖出"
							+ num-- + "号");
				}
			} finally {
				lock.unlock();
			}
			Thread.yield();
		}

	}
}

2、锁方法

package thread;

import java.util.concurrent.locks.ReentrantLock;

public class LockMethod implements Runnable {
	private final ReentrantLock lock = new ReentrantLock();
	private int num = 100;

	public void run() {
		method();
	}

	private void method() {
		// TODO Auto-generated method stub

		while (true) {
			lock.lock();
			try {
				if (num > 0)
					System.out.println(Thread.currentThread().getName() + "卖出了"
							+ num-- + "号");

			} finally {
				lock.unlock();
			}
			Thread.yield();
		}

	}
}

测试类

package thread;

//两个卖票窗口，共卖100张票

public class Test {
	public static void main(String[] args) {
		LockTest t = new LockTest();
//		LockMethod t = new LockMethod(); 
		Thread t1 = new Thread(t, "A");
		Thread t2 = new Thread(t, "B");
		t1.start();
		t2.start();
    }
}