线程是程序运行的基本执行单元。当操作系统（不包括单线程的操作系统，如微软早期的DOS）在执行一个程序时，会在系统中建立一个进程，而在这个进程中，必须至少建立一个线程（这个线程被称为主线程）来作为这个程序运行的入口点。因此，在操作系统中运行的任何程序都至少有一个主线程。

　　线程不仅可以共享进程的内存，而且还拥有一个属于自己的内存空间，这段线程不仅可以共享进程的内存，而且还拥有一个属于自己的内存空间，这段部所使用的数据，如线程执行函数中所定义的变量。

线程:

 

1、线程是轻量级的进程

 

2、线程没有独立的地址空间(内存空间)

 

3、线程是由进程创建的(寄生在进程)

 

4、一个进程可以拥有多个线程–>这就是我们常说的多线程编程

 

5、线程有几种状态：

 

  a、新建状态(new)

 

  b、就绪状态(Runnable)

 

  c、运行状态(Running)

 

  d、阻塞状态(Blocked)

 

  e、死亡状态(Dead)

 

　　sleep(): 强迫一个线程睡眠Ｎ毫秒。 

　　isAlive(): 判断一个线程是否存活。 

　　join(): 等待线程终止。 //只有等到子线程结束了主线程才能执行。(Waits for this thread to die.)

　　activeCount(): 程序中活跃的线程数。 

　　enumerate(): 枚举程序中的线程。 

　　currentThread(): 得到当前线程。 

　　isDaemon(): 一个线程是否为守护线程。 

　　setDaemon(): 设置一个线程为守护线程。(用户线程和守护线程的区别在于，是否等待主线程依赖于主线程结束而结束) 

　　setName(): 为线程设置一个名称。 

　　wait(): 强迫一个线程等待。 

　　notify(): 通知一个线程继续运行。 

　　setPriority(): 设置一个线程的优先级

通过以下两种方法创建 Thread 对象：

Java中“一切皆对象”，线程也被封装成一个对象。我们可以通过继承Thread类来创建线程。线程类中的的run()方法包含了该线程应该执行的指令。我们在衍生类中覆盖该方法，以便向线程说明要做的任务:

声明一个 Thread 类的子类，并覆盖 run() 方法

  1. class myThread extends Thread{
  2.     @Override
  3.     public void run() {
  4.         System.out.println("继承Thread");
  5.     }
  6. }

简单例子

  1.  System.out.println("多线程开始:");
  2.         for(int i=1;i<=10;i++) {
  3.             stat(i);
  4.         }

  1. //随机延迟
  1. public static int reandom(int stop,int stat ){
        return (int)Math.round(Math.random()*(stat-stop)+stop);
    }



  1. public     static void stat(int i){
  2.         System.out.print("线程:"+i+" 开始运行");
  3.         Thread t=new Thread(){
  4.             public void run(){
  5.                 System.out.println(UUID.randomUUID());
  6.             }
  7.         };
  8.         int s=reandom(5,2);
  9.         System.out.print("  延迟:"+s+"秒  唯一UUID:");
  10.         try {
  11.             t.sleep(s*1000);
  12.         } catch (InterruptedException e) {
  13.             e.printStackTrace();
  14.         }
  15.         t.start();
  16.         try {
  17.             t.join();
  18.         } catch (InterruptedException e) {
  19.             e.printStackTrace();
  20.         }
  21.

 

  1.   //固定线程10
  2.         ExecutorService service =Executors.newFixedThreadPool(10);
  4.         for (int i = 0; i < 23; i++) {
  5.             service.execute(new Runnable() {
  6.                 @Override
  7.                 public void run() {
  8.                     System.out.println(Thread.currentThread());
  9.                 }
  10.             });
  11.         }

 可以进一步简化为（jdk8）:

  1.  for (int i = 0; i < 23; i++) {
  2.             service.execute(new Runnable() {
  3.                 @Override
  4.                 public void run() {
  5.                     System.out.println(Thread.currentThread());
  6.                 }
  7.             });
  8.         }

运行结果是一样的:

版权声明：本文为weibanggang原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/weibanggang/p/9468256.html