多线程基础知识总结一---创建命名休眠

多线程基础知识总结一

创建多线程的两种方式

继承Thread类

1. SonThread.java类文件中包含具体执行内容

package com.test;    //注意所在包

public class SonThread extends Thread {

	private String tName;

	public String gettName() {
		return tName;
	}

	public void settName(String tName) {
		this.tName = tName;
	}

	public SonThread() {
		super();
		// TODO Auto-generated constructor stub
	}

	public SonThread(String name) {
		super();
		// TODO Auto-generated constructor stub
		this.tName = name;
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
		super.run();
		Thread.currentThread().setName(tName); // 设置线程名
		for (int i = 0; i < 20; i++) {

			try {
				Thread.sleep(1000); // 休眠函数
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}

			System.out.println(Thread.currentThread().getName() + "-->" + i); // 获取线程名
		}
	}

}

2. SonMain.java中创建多线程并执行

package com.test;

import org.junit.Test;

/*
 * 主线程：执行主(main)方法的线程
 * 单线程程序：Java程序中只有一个线程
 * 执行从main方法开始，从上到下依次执行
 * JVM执行main方法，main方法会进入到栈内存
 * JVM会找操作系统开辟一条main()方法通向CPU的执行路径
 * cpu就可以通过这个路径来执行main方法
 * 而这条路径有一个名字,叫做main（主）线程
 */
public class SonMain {

	@Test
	public void Test() {
		SonThread sT = new SonThread("01");
		sT.start();   //开辟新的栈空间  
		// sT.run(); run()是main进程中的一个方法的调用 该方法中对线程的操作 实际上还是对main进程的操作
		new SonThread("02").start();
	}

}

实现Runnable接口

1. implements Runnable实现代码（这里都是Junit Test Case可以改为Main函数实现）

package com.test;

public class RunnableThread implements Runnable {
	private String tname;

	public String getTname() {
		return tname;
	}

	public void setTname(String tname) {
		this.tname = tname;
	}

	public RunnableThread() {
		super();
		// TODO Auto-generated constructor stub
	}

	public RunnableThread(String tname) {
		super();
		this.tname = tname;
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		Thread.currentThread().setName(tname);
		for (int i = 0; i < 20; i++) {
			System.out.println(Thread.currentThread().getName() + "-->" + i);
		}
	}

}

2. RunnableMain.java中创建多线程并执行

package com.test;

import org.junit.Test;

public class RunnableMain {
	@Test
	public void test(){
		RunnableThread run=new RunnableThread("线程1");
		Thread rd_1=new Thread(run);
		rd_1.start();
		
		Thread rd_02=new Thread(new RunnableThread("线程02"));
		rd_02.start();
		
		new Thread(new RunnableThread("线程003")).start();
	}

}

线程名

设置当前线程名

/*
 * 设置线程名称：
 * 1、使用Thread类中的方法setName
 *     void setName(String name) 改变线程名称，使之与参数name相同
 * 2、创建一个带参数的构造方法，参数传递线程的名称；调用父类的带参构造方法使线程名称传递给父类
 * 让父类给子线程起个名字
 * */

Thread.currentThread().setName("我名由我不由天");

获取并输出当前线程名

System.out.println(Thread.currentThread().getName());

运行效果

进程进入休眠状态

Thread.sleep(1000);

package com.sleep;
/*
 * public static void sleep(long millis)：
 * 使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）
 * 毫秒数结束之后，线程继续执行
 * 
 */
public class Sleep {
	public static void main(String []args){
		for(int i=0;i<=60;i++){
			System.out.println(i);
			//使用Thread类的sleep方法让程序睡眠1秒钟
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			
		}	
	}
}

匿名内部类实现多线程

有继承Thread类和实现Runnable接口两种方式

import org.junit.Test;
public class InnerClassMain {
	@Test
	public void test() {
		// 匿名内部类实现多线程：方式一
		new Thread() {
			@Override
			public void run() {
				// TODO Auto-generated method stub
				super.run();
				Thread.currentThread().setName("我是Thread匿名内部类");
				for (int i = 0; i < 20; i++) {
					System.out.println(Thread.currentThread().getName() + "-->"
							+ i);
				}
			}
		}.start();
		
		// 匿名内部类实现多线程：方式一
		new Thread(new Runnable() {
			@Override
			public void run() {
				Thread.currentThread().setName("我是Runnable匿名内部类");

				// TODO Auto-generated method stub
				for (int i = 0; i < 20; i++) {
					System.out.println(Thread.currentThread().getName() + "-->"
							+ i);
				}
			}
		}).start();
	}
}