Java多线程的测试

一、通过继承Thread类方式创建线程

• 步骤：创建一个Thread类，或者一个Thread子类的对象，即通过继承Thread类的方式创建线程类，重写run()方法。

• 例子：线程1和线程2竞争获取cpu资源，两者获得cpu资源具有不确定性，是随机获取资源的

package com.imooc.thread;

class MyThread extends Thread{
    
    MyThread(String name){
        super(name);
    }
    public void run() {
        for(int i = 0; i<10;i++) {
            System.out.println(getName() + "正在执行" + i);
        }
    }
}
/**
  * 测试线程1和线程2竞争获取cpu资源，两者获得cpu资源具有不确定性，是随机获取资源的
 */
public class ThreadTest1 {
    
    public static void main(String[] args) {
        MyThread mt1 = new MyThread("线程1");
        MyThread mt2 = new MyThread("线程2");
        mt1.start();
        mt2.start();
    }
}

二、测试Thread类的join() 和 join(x ms)方法

• 带参数的join方法：public final void join(long millis)

• 作用：调用join(x)方法的线程，优先执行x毫秒，x时间一过，丧失优先级，其他线程可以竞争cpu资源执行。

package com.imooc.thread;

class MyThread2 extends Thread{
	public void run() {
		for(int i =1;i<=300;i++) {
			System.out.println(getName()+"线程真正执行" + i +"次");
		}
	}
}

/**
 * 带参数的join方法：public final void join(long millis)
 * 调用join(x)方法的线程，优先执行x毫秒，x时间一过，丧失优先级，其他线程可以竞争cpu资源执行。
*/

public class JoinDemo {
	public static void main(String[] args) {
		MyThread2 mt = new MyThread2();
		mt.start();
		
		try {
			//mt线程执行1ms后，丧失优先级，主线程开始竟争资源，然后执行
			mt.join(1);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		for(int i=1;i<=20;i++) {
			System.out.println("主线程执行第" + i +"次");
		}
		
		int main = Thread.currentThread().getPriority();
		System.out.println(main);
		mt.setPriority(Thread.MAX_PRIORITY);
	}
}

三、通过实现Runnable接口创建线程

步骤(三步)：类实例化，根据实例化的对象创建线程类，线程子类调用start方法

package com.imooc.runnable;

public class PrintRunnable implements Runnable {

	//成员变量，共享资源 
	int i = 1;
	//run方法被多个线程共享，这个例子中被t1和t2线程共享，t1和t2共运行10次
	//适合多个线程处理同一个资源
	public void run() {
		while(i<=10) {
			//注意，实现runnable接口的类中，不能直接使用getName方法，因为getName方法是Thread类的方法
			System.out.println(Thread.currentThread().getName() + "正在运行" + (i++));
		}
		
	}

/**
 *  通过实现Runnable接口创建线程有3步，类实例化，根据实例化的对象创建线程类，线程子类调用start方法
 *  
 */
	public static void main(String[] args) {
		//类实例化，分配类的实例，在创建Thread时作为参数传递
		PrintRunnable pr = new PrintRunnable();
		//根据实例化的对象创建线程类
		Thread t1 = new Thread(pr);
		//线程子类调用start方法
		t1.start();
		
		//PrintRunnable pr1 = new PrintRunnable();
		Thread t2 = new Thread(pr);
		t2.start();
	}

}

四、线程间的通信和同步

package com.imooc.queue;
//消费者类，不断消耗n值
public class Consumer implements Runnable{
	//消费者和生产者共享queue
	Queue queue;
	//构造方法
	Consumer(Queue queue){
		this.queue=queue;
	}

	@Override
	public void run() {
		while(true){
			//不断获取queue的n值
			queue.get();
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}	
}

package com.imooc.queue;

//生产者类，不断生产n值
public class Producer implements Runnable{
	//生产者和消费者共享queue 
	Queue queue;
	//构造方法
	Producer(Queue queue){
		this.queue=queue;
	}
	@Override
	public void run() {
		int i=0;
		//这里用了一个死循环，一直输出
		while(true){
			//修改共享queue的n值
			queue.set(i++);
			try {
				//休眠1s
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}	
	}
}

package com.imooc.queue;

public class Queue {
	
	private int n;
	boolean flag=false;
	//flag为false的时候，容器queue中没有数据，需要先生产后获取
	//为true时，有数据，需要先获取再生产
	
	//get方法，获得n的值
	//要加上同步关键字，保证共享资源queue同一时间只有一个线程访问
	public synchronized int get() {
		//flag为false时，没有数据，需要执行等待
		if(!flag){
			try {
				//等待set生成资源
				wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println("消费："+n);
		flag=false;//消费完毕，容器中没有数据
		notifyAll();//唤醒其他线程
		//一般使用这个，因为实际中可能不知道该唤醒哪一个，那把它们都唤醒。
		return n;
	}
	//set方法，设置n的值
	public synchronized void set(int n) {
		//当flag为true，即容器中有数据时，不要再生产了，等待消费完再生产
		if(flag){
			try {
				wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		System.out.println("生产："+n);
		this.n = n;
		flag=true;//生产完毕，容器中已经有数据
		notifyAll();//唤醒其他线程，否则会引起死锁
	}
}

package com.imooc.queue;

public class Test {

	public static void main(String[] args) {
		Queue queue=new Queue();
		//实现runnable接口，创建线程三步走，连起来写
		new Thread(new Producer(queue)).start();
		new Thread(new Consumer(queue)).start();
	}

}