JAVA笔记13__创建线程/线程休眠/等待线程终止/线程中断/守护线程

/**
* 线程：是进程的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行，一个进程最少有一个进程（单线程程序）
* 多线程两种实现方法：1.继承Thread类 2.实现Runnable接口
*/
public class Main {
public static void main(String[] args) {
MyThread t1 = new MyThread();
t1.start(); //启动线程
System.out.println("main");
System.out.println("finished.");
MyRunnable ta = new MyRunnable();
Thread t2 = new Thread(ta);
t2.start(); }
}class MyThread extends Thread{
@Override
public void run() {
for(int i=0;i<10;++i){
System.out.println(new Date()+"-"+i);
}
}
}class MyRunnable implements Runnable{ //推荐使用这个（可以继承其它类，第一种继承了Thread就不能继承其他的）
@Override
public void run() {
for(int i=0;i<10;++i){
System.out.println("MyRunnable"+"-"+i);
}
}
}

public class Main {
public static void main(String[] args) {
System.out.println("当前运行的线程名称："+Thread.currentThread().getName()); //输出main
Thread t1 = new Thread(new MyRunnable(),"fish7");
// System.out.println(t1.getId());
t1.setName("dining");
System.out.println("t1线程是否活动？"+t1.isAlive());
t1.start();
System.out.println("t1线程是否活动？"+t1.isAlive());
}
}class MyRunnable implements Runnable{ //推荐使用这个（可以继承其它类，第一种继承了Thread就不能继承其他的）
@Override
public void run() {
System.out.println("当前运行的线程名称："+Thread.currentThread().getName()); //输出main
}
}

public class Main {
/**
* Sleep方法原理：让当前线程进入休眠状态，让出当次执行的CPU时间，但是不释放监视器的所属权
*/
public static void main(String[] args) {
Thread t1 = new Thread(new MyRunnable());
t1.start();
for(int i=0;i<10;++i){
try {
System.out.println("当前运行的线程名称："+Thread.currentThread().getName()+"-"+i);
Thread.sleep(1000); //不丢失任何监视器的所属权
} catch (InterruptedException ex) {
ex.printStackTrace();
}
}
}
}class MyRunnable implements Runnable{ //推荐使用这个（可以继承其它类，第一种继承了Thread就不能继承其他的）
@Override
public void run() {
for(int i=0;i<10;++i){
try {
System.out.println("当前运行的线程名称："+Thread.currentThread().getName()+"-"+i);
Thread.sleep(1000);
} catch (InterruptedException ex) {
ex.printStackTrace();
}
}
}
}

public class Main {
/**
* Join方法：等待当前线程执行终止，或指定的等待时间（毫秒，纳秒）
*/
public static void main(String[] args) {
Thread t1 = new Thread(new MyRunnable());
t1.start();
for(int i=0;i<10;++i){
try {
System.out.println("当前运行的线程名称："+Thread.currentThread().getName()+"-"+i);
if(i==5)
t1.join(); //等待该线程结束
Thread.sleep(1000);
} catch (InterruptedException ex) {
ex.printStackTrace();
}
}
}
}class MyRunnable implements Runnable{ //推荐使用这个（可以继承其它类，第一种继承了Thread就不能继承其他的）
@Override
public void run() {
for(int i=0;i<10;++i){
try {
System.out.println("当前运行的线程名称："+Thread.currentThread().getName()+"-"+i);
Thread.sleep(1000);
} catch (InterruptedException ex) {
ex.printStackTrace();
}
}
}
}

public class Main {
/**
* interrup方法：只是设置了线程的中断状态为true，并没有真正地中断线程。
*/
public static void main(String[] args) {
Thread t1 = new Thread(new MyRunnable());
t1.start();
for(int i=0;i<10;++i){
try {
System.out.println("当前运行的线程名称："+Thread.currentThread().getName()+"-"+i);
if(i==5)
t1.interrupt(); //中断线程，设置了一个中断标记（中断状态为true）
Thread.sleep(1000);
} catch (InterruptedException ex) {
ex.printStackTrace();
}
}
}
}class MyRunnable implements Runnable{
@Override
public void run() {
int i = 0;
while(!Thread.interrupted()){
try {
System.out.println("当前运行的线程名称："+Thread.currentThread().getName()+"-"+i);
++i;
Thread.sleep(1000); //如果中断标记为true，会抛出异常
} catch (InterruptedException ex) {
ex.printStackTrace();
Thread.currentThread().interrupt();
}
}
}
}

public class Main {
/**
* 自定义标记完成中断线程 *被中断的程序只能自己去中断，别人不得中断它。
*/
public static void main(String[] args) {
MyRunnable my = new MyRunnable();
Thread t1 = new Thread(my);
t1.setPriority(Thread.MAX_PRIORITY); //设置线程的
Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
t1.start();
for(int i=0;i<10;++i){
try {
System.out.println("当前运行的线程名称："+Thread.currentThread().getName()+"-"+i);
if(i==5){
my.setFlag(false); //中断线程
}
Thread.sleep(1000);
} catch (InterruptedException ex) {
ex.printStackTrace();
}
}
}
}class MyRunnable implements Runnable{
private boolean flag = true;
public boolean isFlag(){
return flag;
}
public void setFlag(boolean flag){
this.flag = flag;
}
@Override
public void run() {
int i = 0;
while(flag){
System.out.println(Thread.currentThread().getName()+"-"+i);
i++;
try {
Thread.sleep(1000);
} catch (InterruptedException ex) {
ex.printStackTrace();
}
}
}
}

public class Main {
/**
* 守护线程：当程序中没有用户线程的时候所有守护线程都会自动终止！（守护用户线程）
* setDaemon：将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java虚拟机退出。
* 该方法必须在启动线程前调用。
* yield：暂停当前正在执行的线程对象，并执行其他线程。
*/
public static void main(String[] args) { //主线程是用户线程
MyRunnable my = new MyRunnable();
Thread t1 = new Thread(my);
t1.setDaemon(true); //设置线程为守护线程
System.out.println(t1.isDaemon());
t1.start();
for(int i=0;i<10;++i){
System.out.println("main-"+i);
if(i==5){
Thread.yield(); //让出当次CPU的执行时间
}
try {
Thread.sleep(1000);
} catch (InterruptedException ex) {
ex.printStackTrace();
}
}
}
}class MyRunnable implements Runnable{
@Override
public void run() {
for(int i=0;i<20;++i){
System.out.println("MyRunnablei"+i);
try {
Thread.sleep(1000);
} catch (InterruptedException ex) {
ex.printStackTrace();
}
}
}
}