java--基础--17.1--线程--实现多线程，线程方法

java–基础–17.1–线程–实现多线程，线程方法

1、概念

• 进程：正在运行的程序。每个进程可以由多个线程组成;
• 线程：是进程中的单个顺序控制流，是一条执行路径。
• 并行：指在某一个时间点执行多个任务
• 并发：指在某一个时间段执行多个任务

2、实现多线程有2种方式

2.1、继承继承Thread类，重写run()方法，run()是包含被线程执行的代码

public class MyThread extends Thread {
	public MyThread() {
		super();
	}
	public MyThread(String name) {
		super(name);
	}

	@Override
	//run()用来包含那些被线程执行的代码。
	public void run() {
	for (int i = 0; i < 10; i++) {
		System.out.println(Thread.currentThread().getName()+"  :"+i);
	}
	}

}

测试：
		MyThread my1 = new MyThread();
		MyThread my2 = new MyThread();
		//设置线程名称
		my1.setName("my1");
		my2.setName("my2");

		my1.start();
		my2.start();
		//打印当前线程名字
		System.out.println(Thread.currentThread().getName());
输出：
main
my2  :0
my2  :1
my2  :2
my2  :3
my2  :4
my2  :5
my2  :6
my2  :7
my2  :8
my2  :9
my1  :0
my1  :1
my1  :2
my1  :3
my1  :4
my1  :5
my1  :6
my1  :7
my1  :8
my1  :9

2.2、实现Runnable接口，重写run()方法

public class MyRunnable implements Runnable {

	@Override
	public void run() {
		for (int x = 0; x < 10; x++) {
			System.out.println(Thread.currentThread().getName() + ":" + x);
		}
	}

}
	public static void main(String[] args) {
		// 创建MyRunnable类的对象
		MyRunnable my = new MyRunnable();


		Thread t1 = new Thread(my, "线程1");
		Thread t2 = new Thread(my, "线程2");
		t1.start();
		t2.start();
		//打印当前线程名字
		System.out.println(Thread.currentThread().getName());
	}
输出：
main
线程1:0
线程1:1
线程1:2
线程1:3
线程1:4
线程1:5
线程1:6
线程1:7
线程1:8
线程1:9
线程2:0
线程2:1
线程2:2
线程2:3
线程2:4
线程2:5
线程2:6
线程2:7
线程2:8
线程2:9

3、线程的方法

4、线程方法测试

public class MyThread extends Thread {
	@Override
	public void run() {
		for (int x = 0; x < 5; x++) {
			System.out.println(getName() + ":" + x);
		}
	}
}

4.1、public final void setDaemon(boolean on)

将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。
该方法必须在启动线程前调用。

	MyThread my1 = new MyThread();
		MyThread my2 = new MyThread();

		my1.setName("线程1");
		my2.setName("线程2");

		// 设置守护线程
		my1.setDaemon(true);
		my2.setDaemon(true);
//		Thread.currentThread().setDaemon(true);//当正在运行的线程都是守护线程时，Java 虚拟机退出。

		my1.start();
		my2.start();

		for (int x = 0; x < 5; x++) {
			System.out.println(Thread.currentThread().getName() + ":" + x);
		}
	}
输出：
main:0
main:1
线程1:0
线程2:0
线程2:1
线程2:2
main:2
线程2:3
线程2:4
线程1:1
线程1:2
线程1:3
线程1:4
main:3
main:4

4.2、public final void join()

等待该线程终止/阻塞调用该方法的主线程。

		MyThread my1=new MyThread();
		MyThread my2=new MyThread();
		MyThread my3=new MyThread();
		my1.setName("线程1");
		my2.setName("线程2");
		my3.setName("线程3");
		my1.start();
		try {
			//等待该线程终止。 my1线程结束完才会执行下去，主线程wait堵塞，直到my1完成才唤醒主线程
			my1.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		my2.start();
		my3.start();
	}
输出：
线程1:0
线程1:1
线程1:2
线程1:3
线程1:4
线程2:0
线程2:1
线程2:2
线程2:3
线程3:0
线程2:4
线程3:1
线程3:2
线程3:3
线程3:4

4.3、线程优先级：代表获取cpu时间片几率的高低

• public final int getPriority()：返回线程对象的优先级
• public final void setPriority(int newPriority)：更改线程的优先级。
• 注意：
  • 线程默认优先级是5。
  • 线程优先级的范围是：1-10。

	public static void main(String[] args) {
		MyThread my1 = new MyThread();
		MyThread my2 = new MyThread();
		MyThread my3 = new MyThread();

		my1.setName("线程1");
		my2.setName("线程2");
		my3.setName("线程3");

		// 获取默认优先级
		 System.out.println("线程1优先级"+my1.getPriority());
		 System.out.println("线程2优先级"+my2.getPriority());
		 System.out.println("线程3优先级"+my3.getPriority());
		//设置正确的线程优先级
		my1.setPriority(10);
		my3.setPriority(1);
		 System.out.println("线程1优先级"+my1.getPriority());
		 System.out.println("线程2优先级"+my2.getPriority());
		 System.out.println("线程3优先级"+my3.getPriority());
		 
		 System.out.println("------------------测试---------------");
		my1.start();
		my2.start();
		my3.start();
	}
}

输出：
线程1优先级5
线程2优先级5
线程3优先级5
线程1优先级10
线程2优先级5
线程3优先级1
------------------测试---------------
线程1:0
线程1:1
线程3:0
线程1:2
线程1:3
线程1:4
线程2:0
线程2:1
线程2:2
线程2:3
线程2:4
线程3:1
线程3:2
线程3:3
线程3:4

4.4、线程休眠 public static void sleep(long millis),此时线程会停止，等时间过了，在继续

		MyThread my1 = new MyThread();
		MyThread my2 = new MyThread();
		MyThread my3 = new MyThread();

		my1.setName("线程1");
		my2.setName("线程2");
		my3.setName("线程3");

		my1.start();
		my1.sleep(3*1000);
		System.out.println("线程1结束完了");
		my2.start();
		my3.start();
输出：

线程1:0
线程1:1
线程1:2
线程1:3
线程1:4
线程1结束完了
线程2:0
线程3:0
线程2:1
线程3:1
线程2:2
线程3:2
线程2:3
线程3:3
线程2:4
线程3:4

4.5、线程中断

• public void interrupt()：线程中断。
  • 发出中断请求，状态改为true。
  • 线程中断，不是停止线程，只是一个线程的标志位属性。
  • 如果线程状态为被阻塞状态(sleep、wait、join 等状态)，线程状态退出被阻塞状态，并抛出异常InterruptedException，并重置中断状态为默认状态 false。
• interrupted：检查是否中断，并清除中断状态
• isinterrupted：检查是否中断，不清除中断状态

public class MyThread implements Runnable {
 
    @Override // 可以省略
    public void run() {
        // 一直 run
        while (true) {
        }
    }
 
    public static void main(String[] args) throws Exception {
 
        Thread myThread = new Thread(new MyThread());
        myThread.start();
 
        TimeUnit.SECONDS.sleep(2);
        System.out.println("设置中断状态为true");
        myThread.interrupt();
        System.out.println("线程的中断状态为： " + myThread.isInterrupted());
        TimeUnit.SECONDS.sleep(2);
        System.out.println("线程的运行状态为： " + myThread.getState());
    }
}

结果：
设置中断状态为true
线程的中断状态为： true
线程的运行状态为： RUNNABLE

4.5、public static void yield()：暂停当前正在执行的线程对象，并执行其他线程。

public class MyThread extends Thread {
	@Override
	public void run() {
		for (int x = 0; x < 10; x++) {
			System.out.println(getName() + ":" + x);
			Thread.yield();
		}
	}
}


		MyThread ty1 = new MyThread();
		MyThread ty2 = new MyThread();

		ty1.setName("线程1");
		ty2.setName("线程2");

		ty1.start();
		ty2.start();
输出：

线程1:0
线程2:0
线程1:1
线程2:1
线程2:2
线程2:3
线程2:4
线程2:5
线程1:2
线程2:6
线程1:3
线程1:4
线程2:7
线程1:5
线程2:8
线程2:9
线程1:6
线程1:7
线程1:8
线程1:9