标签：java线程 sleep方法 yield方法 join方法 thread类和runnable接口
方式一：<span style="font-size: 14px;">实现Runnable接口</span>
package thread;
/**
* 创建MyRunnable类，并实现Runnable接口
* @author 学霸联盟 - 赵灿
*/
public class MyRunnable implements Runnable {
// 必须重写Runnable接口中的方法，不重写会出现语法错误
// Runnable接口中只声明了一个方法run()
@Override
public void run() {
// 线程执行的代码
System.out.println("MyRunnable-run");
}
}方式二：
package thread;
/**
* 创建MyThread类，并继承Thread接口
* @author 学霸联盟 - 赵灿
*/
public class MyThread extends Thread {
/*
* Thread类也实现了Runnable接口，并重写了接口中的run方法
* 所以此处如果没有重写run方法，不会出现语法错误，但创建的这个线程也就没有意义了
*/
@Override
public void run() {
// 线程执行的代码
System.out.println("MyThread-run");
}
}package thread;
/**
* 创建测试类Test，测试以上两种方式创建的线程
* @author 学霸联盟 - 赵灿
*/
public class Test {
public static void main(String[] args) {
/*********** 方式一 ************/
// 创建一个MyRunnable类型的对象mr
MyRunnable mr = new MyRunnable();
// 创建一个线程对象t；并将mr作为参数传入Thread对象
Thread t = new Thread(mr);
/*
* 注意：启动线程调用的是Thread类中的start方法，而不是调用run方法；
* 如果直接调用run方法，将只表示run方法的调用，不会启动线程；
* 调用start方法启动线程t，线程启动后，会自动调用对象mr中的run方法
*/
t.start();
/*********** 方式二 ************/
// 创建一个MyThread类型的对象mt
MyThread mt = new MyThread();
// 因为start方法在Thread类中声明，MyThread类继承了Thread类
// 所以此处使用对象mt调用的start方法是从父类Thread中继承的方法
mt.start();
}
}
输出结果：
MyRunnable-run
MyThread-run
或
MyThread-run
MyRunnable-run由于多个线程是并行执行的，即同时运行。实例：
package thread.sleep;
/**
* 创建SleepDemo类
* 用于测试sleep方法
* @author 学霸联盟 - 赵灿
*/
public class SleepDemo{
public static void main(String[] args){
System.out.println("主线程正在执行");
System.out.println("主线程休眠开始");
// 执行Thread.sleep();可能产生异常，使用try-catch语句捕获异常
try {
// 这条语句会被主线程执行，执行后主线程休眠1000毫秒（1秒）
Thread.sleep(1000);
} catch (InterruptedException e) {
// 如果try中的代码产生异常，程序执行这条输出语句
System.out.println("线程休眠时出现异常");
}
System.out.println("主线程休眠结束");
System.out.println("主线程恢复执行");
}
}
输出结果：
主线程正在执行
主线程休眠开始【这里会休眠（停止）1秒，1秒后继续输出以下内容】
主线程休眠结束
主线程恢复执行实例：
package thread.yield;
/**
* 创建YieldDemo类
* 用于测试线程的让步执行
* @author 学霸联盟 - 赵灿
*/
public class YieldDemo {
public static void main(String[] args) {
//声明ThreadA和ThreadB的对象
ThreadA ta = new ThreadA();
ThreadB tb = new ThreadB();
//启动线程ta
ta.start();
//启动线程tb
tb.start();
}
}
/**
* 创建ThreadA类，并继承Thread类
* @author 学霸联盟 - 赵灿
*/
class ThreadA extends Thread{
//重写父类中的run方法
@Override
public void run() {
//循环30次
for (int i = 1; i <= 30; i ++) {
/*
* 每循环一次ThreadA类的对象（本例是ta）就会让出一次CPU的使用权，
* 给其他线程执行（这个例子中是主线程和ThreadB的对象tb）
*/
Thread.yield();
//输出一个字符串，为了在结果中可以看到线程ta的执行频率
System.out.println("ThreadA-" + i);
}
}
}
/**
* 创建ThreadB类，并继承Thread类
* @author 学霸联盟 - 赵灿
*/
class ThreadB extends Thread{
//重写父类中的run方法
@Override
public void run() {
//循环30次
for (int i = 1; i <= 30; i ++) {
//输出一个字符串，为了在结果中可以看到线程tb的执行频率
System.out.println("ThreadB--" + i);
}
}
}
输出结果：输出顺序是不确定的；多数情况下，线程tb会先执行完，线程ta后执行完，而且线程tb的执行频率要比线程ta高，但不是绝对的实例：
package thread.join;
/**
* 创建JoinDemo类
* 用于测试线程的让步执行
* @author 学霸联盟 - 赵灿
*/
public class JoinDemo {
public static void main(String[] args) {
//创建ThreadA的对象ta
ThreadA ta = new ThreadA();
//启动线程ta
ta.start();
}
}
/**
* 创建ThreadA类，并继承Thread类
* @author 学霸联盟 - 赵灿
*/
class ThreadA extends Thread{
//重写父类中的run方法
@Override
public void run() {
//创建ThreadB的对象tb；线程ta运行后便会先执行此句
ThreadB tb = new ThreadB();
//启动线程tb；线程tb启动后，此时线程ta和tb共同等待调度程序的选取
tb.start();
//循环30次
for (int i = 1; i <= 30; i ++) {
/*
* 当i等于10时，执行tb.join();
* 使线程tb插队执行到线程ta前面执行
* 线程ta被阻塞
*/
if ( i == 10 ) {
try {
/*
* 只需插队一次即可
* 在i小于10时，线程ta和tb共同等待调度程序的选取执行
* i==10时，执行tb.join();
* 执行后，线程ta被阻塞，只执行线程tb；
* 直至线程tb执行完，ta才会恢复至可运行态
* 其中ta是代码的执行者，tb是代码的调用者
*/
tb.join();
} catch (InterruptedException e) {
//输出栈内存中的异常信息
e.printStackTrace();
}
}
//输出一个字符串，为了在结果中可以看到线程ta的执行频率
System.out.println("ThreadA-" + i);
}
}
}
/**
* 创建ThreadB类，并继承Thread类
* @author 学霸联盟 - 赵灿
*/
class ThreadB extends Thread{
//重写父类中的run方法
@Override
public void run() {
//循环30次
for (int i = 1; i <= 30; i ++) {
//输出一个字符串，为了在结果中可以看到线程tb的执行频率
System.out.println("ThreadB--" + i);
}
}
}
由于输出结果的顺序完全不确定，这里同学们一定要自行测试版权声明：本文为博主原创文章，未经博主允许不得转载。
标签：java线程 sleep方法 yield方法 join方法 thread类和runnable接口
原文地址：http://blog.csdn.net/ixueba/article/details/47611221
