第八天：线程

线程

什么是线程：

任务管理器可以有多个进程，每个进程运行的都是可执行程序，一个可执行程序就是一个软件，可执行程序的本质就是在计算机当中运行的一块代码

进程：可以看成是在计算机当中运行的一块代码

线程：可以看成是在计算机当中运行的一小块代码

线程与进程的关系

1. 一个进程中可以有多个线程，至少得有一个线程；

2. 上面说一个进程可以狭隘的看成是一大段代码，那其实线程也是一段代码

3. 线程是进程中的最小单位；

4. 也可以把线程看成是一个轻量级的进程

线程的作用：看下面两种理解方式：

①可以将代码中（软件）的某些独立的功能包装起来，单独作为任务交给CPU处理！

②将需做的某个功能封装成一个线程体，该线程可以独立的获得CPU分配的资源

cpu在高速的切换线程从而实现多功能同时运行。

public class Data extends  Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(i+"次：sf放大了");
        }
    }
}



public class Date1 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(i+"次：大鱼人教你做大人");
        }
    }
}



public class Data extends  Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(i+"次：sf放大了");
        }
    }
}



//输出结果
0次：大鱼人教你做大人
0次：sf放大了
1次：大鱼人教你做大人
1次：sf放大了
2次：sf放大了
3次：sf放大了
4次：sf放大了

Runnable接口

Thread线程类本质是实现Runnable接口

public class CkThread implements Runnable{

    @Override
    public void run() {
        System.out.println("ok");
    }
}

-------------------------------------------------------
  public static void main(String[] args) {
       
        CkThread cc=new CkThread();
        Thread dd1=new Thread(cc);
        dd1.start();
    }

继承Thread 和实现Runnable的区别

1、继承有局限，Java中类只能够单继承

2、实现的方式，我们的类在业务上可以继承它本应该有的类，同时可以实现接口变成一个线程类

3、关于数据共享的问题：就看所谓被共享的数据所在的类的对象被创建了几个

Thread类

线程休眠sleep

线程类Thread当中有一个static void sleep(long millis)方法，在指定的毫秒数内让当前正在执行的线程休眠

 public static void main(String[] args) throws InterruptedException {
        System.out.println("1");
        //输出1之后延迟10秒再输出2
        Thread.sleep(10000);
        System.out.println("2");
    }

倒计时

 public static void main(String[] args) throws InterruptedException {
        System.out.println("1");
        //弹出窗口
        Frame f = new Frame("我giao");
        Label label = new Label("10");
        label.setBackground(Color.RED);
        // 字体对象
        Font font = new Font("宋体",Font.BOLD,666);
        label.setFont(font);
        label.setAlignment(Label.CENTER);
        f.add(label);

        f.setSize(780, 780);
        f.setLocationRelativeTo(null);
        f.setVisible(true);

        for (int i = 10; i >= 0; i--) {
            label.setText(i+"");
            Thread.sleep(1000);
        }
        System.out.println("2");

    }

线程的优先级

/*
	 * 线程优先级，指的一个线程对象，获得CPU机会的大小
	 * 1.获得和设置了优先级
	 * 2.一个线程对象的创建：优先级跟所在线程环境的优先级一致的
	 * 		1.Java main线程中  Thread  :java自己写好的线程
	 * 		2.自定义线程        在Java写好的里测试创建对象
	 * 		3.自定定义线程：中创建java 已经写好的线程
	 * */
	public static void main(String[] args) {
		//获得到了主线程的对象引用
		Thread ct = Thread.currentThread();//获取当前线程的对象引用
		/*
		 * 获得对象的优先级或者设置优先级：提供了方法
		 *  1.int getPriority() 返回线程的优先级 
			2.void setPriority(int newPriority) 更改线程的优先级 
		 * */
		int main = ct.getPriority();
		System.out.println(main);//5
		//线程优先级1~5~10
		ct.setPriority(4);
		System.out.println(ct.getPriority());
		
		//当前在主线程中，创建的线程与主线程的优先级一致
		Thread thread = new Thread();
		System.out.println(thread.getPriority());
		
		MyThread mt = new MyThread();
		System.out.println("mt:"+mt.getPriority());
		//mt线程环境优先级修改为10
		mt.setPriority(6);
		mt.start();
	}

守护线程

/*
	 *  boolean isDaemon()  测试该线程是否为守护线程 :是否为后台
		void setDaemon(boolean on) 将该线程标记为守护线程或用户线程
		
		1.启动的线程不修改为后台或者前台
		2.一个线程的是否为后台线程与创建的环境一致
	 * */
	public static void main(String[] args) {
		Thread main = Thread.currentThread();
		boolean daemon = main.isDaemon();
		System.out.println(daemon);//false所以是前台线程
		
		/*
		 * 修改主线程为后台线程
		 * 		启动的线程不能修改为后台或者前台线程
		 * */
		//main.setDaemon(true);
		//System.out.println(main.isDaemon());
		
		Thread t = new Thread();
		t.setDaemon(true);
		System.out.println(t.isDaemon());
		
		/*如果所有的前台线程都死了，那么后台线程也会自动的死亡；
		 *但是前台线程死了，后台线程不一定立即死亡（可能还需要收尸...）
		 * */
		MyThread myThread = new MyThread();
		myThread.setDaemon(true);
		/*
		 * main主线程：执行完毕：主线程自然死亡
		 * 1.主线程死了：后台会自动死亡：自定义线程没有打印run方法里面的内容，因为自动死亡
		 * 2.也有可能会打印：因为后台不一定马上死
		 * */
		myThread.start();//后台线程启动，执行run方法里内容
	}