【java基础-线程】

线程，进程

1，CPU核心数和线程数的关系

六个核心数 = 12个线程

2，CPU时间片轮转机制: 随机切换机制

3，什么是进程和线程

进程 > 线程
一个进程至少一个线程 或 多个线程
如果一个进程，还有一个线程没有杀掉 还存活，那么进程还存活 （线程依附进程）
进程A { 线程一， 线程二，线程三 … }
进程B { 线程一}
进程C {} 挂了；

4，并行和并发

Java默认就是多线程的
并行：四个跑道
并发：10秒钟，我服务器的吞吐量
十秒钟，多少车流量，多少车跑过去
高并发编程的意义，好处
6核12线程 —> 平衡使用我们的线程

5，启动方式（3）

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class NewThread {
// 方法一： 实实在在的线程
private static class Student extends Thread{
@Override
public void run() {
super.run();
System.out.println(“Student 1”);
}
}

// 第二种方法 任务  实现Runnable  交给Thread执行
private static class  Student2 implements  Runnable{
    @Override
    public void run() {
        System.out.println("Student 2");
    }
}

// 第三种 也是任务 但是有返回值 也是 Thread.start
private static class Student3 implements Callable<String> {
    @Override
    public String call() throws Exception {
        Thread.sleep(5000);
        System.out.println("Student 3");
        return " call return student 3";
    }
}

public static void main(String[] args) {
    Student student = new Student();
    student.start();
    
    // 任务无法自己start 必须寄存在Thread
    Student2 student2 = new Student2();
    new Thread(student2).start();

    //任务3 有返回值
    Student3 student3 = new Student3();
    FutureTask<String> futureTask = new FutureTask<>(student3);
    new Thread(futureTask).start();
    try {
        System.out.println(futureTask.get());
    } catch (InterruptedException e) {
        e.printStackTrace();
    } catch (ExecutionException e) {
        e.printStackTrace();
    }
}

}
TODO 【面试题】 就是 run 和start的区别 ？
答：run是函数调用 和线程没有任何关系， .start会走底层 会走系统层 最终调度到 run函数，这才是线程。

TODO 【面试题】 如何控制线程的执行顺序 ？
答：join来控制 让t2获取执行权力，能够做到顺序执行

TODO 【面试题】 多线程中的并行和并发是什么？
答：四个车道，四辆车并行的走，就是并行， 四个车道中，五秒钟多少的车流量，多少的吞吐量一样

TODO 【面试题】在Java中能不能指定CPU去执行某个线程？
答：不能，Java是做不到的，唯一能够去干预的就是C语言调用内核的API去指定才行，这个你回答的话，面试官会觉得你研究点东西

TODO【面试题】在项目开发过程中，你会考虑Java线程优先级吗？
答：不会考虑优先级，为什么呢？ 因为线程的优先级很依赖与系统的平台，所以这个优先级无法对号入座，无法做到你想象中的优先级，属于不稳定，有风险
因为某些开源框架，也不可能依靠线程优先级来，设置自己想要的优先级顺序，这个是不可靠的
例如：Java线程优先级又十级，而此时操作系统优先级只有2~3级，那么就对应不上

TODO 【面试题】sleep和wait又什么区别？
答：sleep是休眠，等休眠时间一过，才有执行权的资格，注意：只是又有资格了，并不代表马上就会被执行，什么时候又执行起来，取决于操作系统调度
wait是等待，需要人家来唤醒，唤醒后，才有执行权的资格，注意：只是又有资格了，并不代表马上就会被执行，什么时候又执行起来，取决于操作系统调度
含义的不同：sleep无条件可以休眠， wait是某些原因与条件需要等待一下（资源不满足）

TODO 【面试题】 在Java中能不能强制中断线程的执行？
答：虽然提供了 stop 等函数，但是此函数不推荐使用，为什么因为这种暴力的方式，很危险，例如：下载图片5kb，只下载了4kb 等
我们可以使用interrupt来处理线程的停止，但是注意interrupt只是协作式的方式，并不能绝对保证中断，并不是抢占式的

TODO 【面试题】 如何让出当前线程的执行权？
答：yield方法，只在JDK某些实现才能看到，是让出执行权

TODO 【面试题】sleep，wait，到底那个函数才会 清除中断标记？
答：sleep在抛出异常的时候，捕获异常之前，就已经清除

public static void main(String [] args) throws InterruptedException {
    ThreadJoinTest t1 = new ThreadJoinTest("A");
    ThreadJoinTest t2 = new ThreadJoinTest("B");
    t1.start();
    /**join的意思是使得放弃当前线程的执行，并返回对应的线程，例如下面代码的意思就是：
     程序在main线程中调用t1线程的join方法，则main线程放弃cpu控制权，并返回t1线程继续执行直到线程t1执行完毕
     所以结果是t1线程执行完后，才到主线程执行，相当于在main线程中同步t1线程，t1执行完了，main线程才有执行的机会
     */
    t1.join(); // 让t1获取执行权
    t2.start();
}

public class DaemonThread {

public static void main(String[] args) throws InterruptedException {

    Thread t = new Thread() {
        @Override
        public void run() {
            for (int i = 0; i < 50; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(getName() + "---" + i);
            }
        }
    };
    t.setDaemon(true);
    t.start(); 
    Thread.sleep(10000);
}

}

public class DaemonThread {

public static void main(String[] args) throws InterruptedException {

    Thread t = new Thread() {
        @Override
        public void run() {
            for (int i = 0; i < 50; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(getName() + "---" + i);
            }
        }
    };
    t.setDaemon(true);
    t.start();

    // 主线程是为了等待守护线程10s
    Thread.sleep(10000);
    // 走到这里主线程结束，不管守护线程是否执行完，都必须结束
}

}