Java多线程入门（一）

会当凌绝顶，一览众山小

| @Author：TTODS

Java线程实现多线程的两种方式

• 继承Thread类，重写run方法

//MyThread.java文件
//MyThread类继承Thread类
public class MyThread extends Thread{
       //重写run方法
       @Override
       public void run() {
             for(int i=0;i<500;i++) {
                    System.out.println("我是子线程,i="+i+"(>_<)!");
             }
       }
}

//Test1.java文件
//Test1类,用于测试
public class Test1 {
       public static void main(String[] args) {
             //实例化子线程对象
             MyThread mt = new MyThread();
             //启动子线程，一定是使用start方法，而不是run方法，调用run方法为普通的方法调用，不能达到多线程的效果
             mt.start();
             for(int i=0;i<500;i++) {
                    System.out.println("(>_<)!我是主线程,i="+i);
             }
       }
}

运行结果

• 实现Runnable接口(实现接口中的run方法)，在用Runnable实现类初始化Thread对象

//MyRunnable.java文件
//MyRunnable类实现Runnable接口
public class MyRunnable implements Runnable{
       //实现接口中的run方法
       public void run() {
             for(int i=0;i<1000;i++)
             System.out.println("\\(>_<)/我是MyRunnable,i="+i);
       }
}

//Test1.java文件,用于测试
public class Test1 {
       public static void main(String[] args) {
              //实例化Runnable接口的实现类
             MyRunnable mr = new MyRunnable();
             //使用Runnable接口实现类的对象初始化Thread对象
             Thread thread = new Thread(mr);
             //使用start方法启动线程
             thread.start();
             for(int i=0;i<500;i++) {
                    System.out.println("(>_<)!我是主线程,i="+i);
             }
       }
}

运行结果

线程中的相关方法

• setPriority()
  设置线程优先级，可设置成1-10，默认是5

//MyThread.java文件
//MyThread类继承Thread类，下面的方法都会使用此类
public class MyThread extends Thread{
       public MyThread() {
             super();
       }
       //构造函数,为线程取名字
       MyThread(String name){
             this();
             setName(name);
       }
       //重写run方法
       @Override
       public void run() {
             for(int i=0;i<500;i++) {
                    System.out.println("我是"+getName()+",i="+i+"(>_<)!");
             }
       }
}

//SetPriorityTest.java文件
public class SetPriorityTest {
       public static void main(String[] args) {
             MyThread mt1 = new MyThread("线程1");
             MyThread mt2 = new MyThread("线程2");
             mt1.setPriority(1);//将 子线程1的优先级设为1
             mt2.setPriority(10);//将 子线程2的优先级设为10
             //启动两个线程
             mt1.start();
             mt2.start();
       }
}

运行结果

• sleep()
  使正在运行的线程“睡眠”一段时间,将CPU交给其他线程。

//SleepTest.java文件

import java.util.Date;
public class SleepTest {
       public static void main(String[] args) {
             MyTime t = new MyTime();
                           t.start();
       }
}

//子线程类
class MyTime extends Thread{
//重写run方法，作用是每秒输出一次当前的时间
       @Override
       public void run() {
             // TODO 自动生成的方法存根
             while(true) {
                    System.out.println(new Date());
                    try {
                    //sleep方法，让当前线程“睡”一段时间，参数是毫秒
                           Thread.sleep(1000);
                    } catch (InterruptedException e) {
                           // TODO 自动生成的 catch 块
                           e.printStackTrace();
                }
            }
       }
}

运行结果

• join()
  将一个线程加入到另外一个线程中，是两个线程从交替执行变为循序执行。

//JoinTest.java文件
public class JoinTest {
       public static void main(String[] args) {
             MyThread mt = new MyThread("子线程");
             //启动子线程
             mt.start();
             //主线程第一个循环输出
             for(int i=0;i<100;i++) {
                    System.out.println("这里是主线程，i="+i);
             }
             System.out.println("join");
             //使用join，
             try {
                    mt.join();
             } catch (InterruptedException e) {
                    // TODO 自动生成的 catch 块
                    e.printStackTrace();
             }
             //主线程的第二次循环输出
             for(int i=0;i<100;i++) {
                    System.out.println("这里是主线程,i="+i);
             }
       }
}

运行结果
主线程的第一个循环输出(使用join前)，主线程与子线程同时进行，主线程的第二个循环输出(使用join后)，主线程等待子线程结束才继续运行。

• yield()
  将线程由运行状态变为可运行状态，是其他线程获得运行机会，但不保证可以转让

//YieldTest.java文件
public class YieldTest {
       public static void main(String[] args) {
             MyThread mt = new MyThread("子线程");
             //启动子线程
             mt.start();
             for(int i=0;i<400;i++) {
                    System.out.println("主线程,i="+i);
                    //每当i可以被10整除的时候，调用yield()方法;
                    if(i%10==0) {
                           Thread.yield();
                           System.out.println("---------yield----------");
                    }
             }
       }
}

运行结果

• interrupt()
  interrupt方法可以使正在sleep的线程，“醒”过来。

//InterruptTest.java文件
public class InterruptTest {
	public static void main(String[] args) {
		SleepThread st = new SleepThread();
		//启动子线程
		st.start();
		//等待子线程1秒,确保子线程的台词在主线程前面(>_<)!
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e1) {
			// TODO 自动生成的 catch 块
			e1.printStackTrace();
		}
		System.out.println("500年？你看我数五秒就叫醒这个偷懒的家伙");
		for(int i=1;i<=5;i++) {
			System.out.println(i);
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO 自动生成的 catch 块
				e.printStackTrace();
			}
		}
		st.interrupt();
	}
}
//子线程类
class SleepThread extends Thread{
	@Override
	public void run() {
		System.out.println("子线程:我要先睡500年");
		try {
			//让线程sleep一个很长很长的时间
			Thread.sleep(1000000000);
		} catch (InterruptedException e) {
			//捕获到中断异常时的异常处理
			System.out.println("子线程:谁啊！这么快就吵醒我！好吧我先去工作");
		}
		//sleep结束后要运行的代码
		for(int i=0;i<100;i++) {
			System.out.println("子线程:i="+i);
		}
	}
}

运行结果

---

- THE END -