java多线程

多线程是cpu操作的最小单元，通过多重线程调度算法如:FIFO()、时间片轮换、最短作业等，通俗来将用多线程就是将一件事分成若干个组成交给若干个线程处理，从而加快了处理速度

   就一点：提高计算机CPU的利用率

分为主线程和子线程，main方法称之为主线程，其余的为子线程，子线程可细分为守护线程和非守护线程（其含义与守护进程和非守护进程相差不大）

public static void main(String[] args) {
   new Thread(()->{
       System.out.println("myThread");
       //通过.setDaemon(true)将子线程设置为守护进程
   }).setDaemon(true);
}

一、继承Thread

@SneakyThrows
public static void main(String[] args) {
    Thread t1 = new myThread();
    t1.setName("myThread");
    t1.start();
}
// 继承Thread 创建线程
class myThread extends Thread{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() +" Is Running ....");
    }
}

二、实现Runnable

@SneakyThrows
public static void main(String[] args) {
    myThread2 t2 = new myThread2();
    t2.setName("myThread2");
    t2.run();
}
//实现Runnable 创建线程
class myThread2 implements Runnable {
   private  String name;
   public void setName(String name){
       this.name = name;
   }
    @Override
    public void run() {
       Thread.currentThread().setName(name);
        System.out.println(Thread.currentThread().getName() + " Is Running ....");
    }
}

三、实现Callable

@SneakyThrows
public static void main(String[] args) {
    //FutureTask 结果对象（下一篇再总结）
    FutureTask futureTask = new FutureTask<>(thread3);
    new Thread(futureTask).start();
    System.out.println(futureTask.get());
}
//实现Runnable 创建线程
class myThread3 implements Callable {
    @Override
    public String call(){
        return Thread.currentThread().getName() + " Is Running ....";
    }
}

New(初始)：新建状态，当线程创建完成时为新建状态，即new Thread(…)，还没有调用start方法时，线程处于新建状态。

RUNNABLE(运行)：在 Java 虚拟机中执行的线程处于这种状态。。

BLOCKED(阻塞)：被阻塞等待监视器锁的线程处于这种状态

WAITING(等待)：无限期等待另一个线程执行特定操作的线程处于此状态。

TIMED_WAITING(超时等待):等待另一个线程执行操作达指定等待时间的线程处于此状态。

TERMINATED(终止)：已退出的线程处于此状态。

    
    public static native Thread currentThread();

    
    public static native void yield();

    
    public static native void sleep(long millis) throws InterruptedException;

    
    public static void sleep(long millis, int nanos)
    throws InterruptedException {}

    
    private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize) {
        init(g, target, name, stackSize, null, true);
    }

    
    private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize, AccessControlContext acc,
                      boolean inheritThreadLocals) {}
  
  public synchronized void start() {}
  
  public void run() {}
  
  private void exit() {}
   
   public final void stop() {}
   
   public void interrupt() {}
   
    public boolean isInterrupted() {}
   
    public final native boolean isAlive(){};
    
    public final void setPriority(int newPriority){}
    
    public final int getPriority() {}
    
    public final synchronized void setName(String name) {}
    
    public final String getName() {}
    
    public final ThreadGroup getThreadGroup(){}
    
    public static int activeCount() {}
    
    public final synchronized void join(long millis,int nanos){}
    
     public static void dumpStack(){}
    
     public ClassLoader getContextClassLoader() {}
    
     public StackTraceElement[] getStackTrace() {}