Java语言基础--线程
1.创建和启动线程
线程类必须实现Runnable接口或者扩展Thread类，并且实现run方法，run方法没有参数没有返回值不允许抛出异常。调用start实例方法启动一个线程。调用该方法后，线程准备启动，只有获得CPU时，start将自动调用run，线程才真正启动。
public class DefineThread {
/**
* 通过继承java.lang.Thread类定义线程
*/
class ThreadA extends Thread{
/**
* 当线程被运行时调用此方法
*/
public void run(){
System.out.println("ThreadA begin,");
System.out.println("ThreadA end.");
}
}
/**
* 通过实现java.lang.Runnable接口定义线程
*/
class ThreadB implements Runnable{
public void run(){
System.out.println("ThreadB begin,");
System.out.println("ThreadB end.");
}
}
public static void main(String[] args) {
DefineThread test = new DefineThread();
//线程的运行具有不确定性，先启动的线程不一定先运行，取决于虚拟机。
Thread threadA = test.new ThreadA();
Runnable tb = test.new ThreadB();
Thread threadB = new Thread(tb);
threadA.start();
threadB.start();
}
}
2.停止线程
为线程设置一个布尔属性，表示线程是否运行，在run方法中适当地检测标志位，为true时继续运行，需要停止线程时设置标志位为false。
class MyThread extends Thread {
private boolean running = false;
public void start() {
running = true;
super.start();
}
public void run() {
try {
while(running) {
System.out.println("mythread is running");
Thread.sleep(200);
}
}catch(InterruptedException e){
}
System.out.println("mythread stop.");
}
public void stopMyThread() {
running = false;
}
}
public class ThreadStop {
public static void main(String[] args) {
MyThread mt = new MyThread();
mt.start();
try{
Thread.sleep(2000);
}catch(InterruptedException e){
}
mt.stopMyThread();
}
}
3.线程互斥
在类的方法声明中使用synchronized可以保证在同一时刻只有一个线程能够进入该方法。
public class ThreadSynchronized {
public synchronized void synchronizedMethod() {
System.out.println("Thread in method is：" + Thread.currentThread().getName());
System.out.println("other thread can't enter the method now.");
try{
Thread.sleep(5000);
}catch(InterruptedException e){
}
System.out.println(Thread.currentThread().getName() + " have done its work, leaving method.");
}
public static void main(String[] args){
final ThreadSynchronized obj = new ThreadSynchronized();
Thread thread1 = new Thread() {
public void run() {
obj.synchronizedMethod();
}
};
Thread thread2 = new Thread() {
public void run() {
obj.synchronizedMethod();
}
};
thread1.start();
try{
Thread.sleep(100);
}catch(InterruptedException e){
}
thread2.start();
}
}
4.线程协作
在synchronized代码块中使用wait方法，能够使当前线程进入等待状态，并释放当前线程拥有的对象锁。在synchronized代码块中使用notify或者notifyAll方法，当前线程释放对象锁，唤醒其它等待该对象锁的线程。当有多个线程都在等待该对象锁时，由虚拟机决定被唤醒的线程。
class CubbyHole {
private Object slot;
public CubbyHole() {
slot = null;
}
public synchronized void putIn(Object obj) throws InterruptedException{
System.out.println(Thread.currentThread().getName() + "want to putin a object");
while(slot != null){
System.out.println("cubbyhole is full, need to wait.");
wait();
System.out.println(Thread.currentThread().getName() + "wake up!");
}
slot = obj;
System.out.println("fill a object, notify others.");
notifyAll();
}
public synchronized Object takeOut()throws InterruptedException {
System.out.println(Thread.currentThread().getName() + "want to takeout an object.");
while(slot == null){
System.out.println("the cubbyhole is empty, need to wait");
wait();
System.out.println(Thread.currentThread().getName() + "wake up!");
}
Object obj = slot;
slot = null;
System.out.println("clear the cubbyhole, notify others.");
notifyAll();
return obj;
}
}
public class CubbyHoleMain {
public static void main(String[] args){
final CubbyHole ch = new CubbyHole();
Runnable runA = new Runnable() {
public void run() {
try{
String str;
Thread.sleep(500);
for(int i = 1; i < 11; i++){
str = "multithread" + i;
ch.putIn(str);
System.out.println(Thread.currentThread().getName() + " putin ' " + str + " ' ");
}
/*str = "programming";
ch.putIn(str);
System.out.println(Thread.currentThread().getName() + " putin ' " + str + " ' ");
str = "with java";
ch.putIn(str);
System.out.println(Thread.currentThread().getName() + " putin ' " + str + " ' ");*/
}catch(InterruptedException e){
e.printStackTrace();
}
}
};
Runnable runB = new Runnable() {
public void run() {
try{
Object obj;
obj = ch.takeOut();
System.out.println(Thread.currentThread().getName() + "takeout ' " + obj + " ' ");
Thread.sleep(500);
for(int i = 0; i < 9; i++){
obj = ch.takeOut();
System.out.println(Thread.currentThread().getName() + "takeout ' " + obj + " ' ");
}
/* obj = ch.takeOut();
System.out.println(Thread.currentThread().getName() + "takeout ' " + obj + " ' ");*/
}catch(InterruptedException e){
e.printStackTrace();
}
}
};
Thread threadA = new Thread(runA, "threadA");
Thread threadB = new Thread(runB, "threadB");
threadA.start();
threadB.start();
}
}
5.线程优先级
Java线程优先级分为10个级别，数字越大级别越高，默认为5级。Thread.MAX_PRIORITY和Thread.MIN_PRIORTY和Thread.NORM_PRIORTY是Thread的3个static final成员，分别是10，1，5。
public class Priority {
static class MyThread extends Thread{
private int ID = 0;
public MyThread(int id){
this.ID = id;
}
public void run(){
System.out.println("MyThread-" + this.ID +
" begin! Priority: " + this.getPriority());
System.out.println("MyThread-" + this.ID + " end!");
}
}
public static void main(String[] args) {
//建立3个优先级不同的线程
MyThread[] myThreads = new MyThread[3];
for (int i=0; i<3; i++){
myThreads[i] = new MyThread(i+1);
//三个线程的优先级分别是1，4，7
myThreads[i].setPriority(i*3+1);
}
//按优先级从低到高启动线程
for (int i=0; i<3; i++){
myThreads[i].start();
}
//先启动的线程不一定先运行，虚拟机会考虑线程的优先级，同等情况下，优先级高的线程先运行
}
}
