java cpu多线程测试_Java多线程的测试

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();

}

}