关于java:线程的创建和常用方法

一、过程和线程
1. 过程
过程（Process）是程序进行资源（CPU、内存、磁盘等）调配和调度的根本单位，是正在运行的程序的实例，一个程序能够蕴含一个或多个过程。
2. 线程
线程是操作系统可能进行运算和调度的最小单位。它被蕴含在过程之中，是过程中的理论运作单位。一条线程指的是过程中一个繁多程序的控制流，一个过程中能够并发多个线程，每条线程并行执行不同的工作。
3. 过程和线程的关系和区别

一个操作系统中能够有多个过程, 一个过程中能够蕴含一个线程或多个线程。
每个线程能共享同一个过程中的内存，线程也有独立的空间（栈、程序计数器）。
线程须要的资源更少，能够看做是一种轻量级的过程，互相通信更加不便。

二、线程的创立形式

继承 Thread 类

重写 run 办法

创立 Thread 对象

启动线程

// 重写 run 办法
@Override
public void run() {for (int i = 0; i < 100; i++) {System.out.println(Thread.currentThread().getName() + "线程执行了" + i + "次");
    }
}
}

public class ThreadDemo {public static void main(String[] args) {
    // 创立 Thread 对象
    MyThread thread = new MyThread();
    // 启动线程
    thread.start();}
}

2. 实现 Runnable 接口

实现 Runnable 接口
重写 run 办法
创立 Thread 对象，传入 Runnable 对象
启动线程

// 实现 run 办法
@Override
public void run() {for (int i = 0; i < 100; i++) {System.out.println(Thread.currentThread().getName() + "线程执行了" + i + "次");
    }
}
}

public class RunnableDemo{public static void main(String[] args) {
    // 创立 Thread 对象，传入 Runnable 对象
    Thread thread = new Thread(new MyRunnable());
    // 启动线程
    thread.start();

    // Lambda 表达式创立
    new Thread(() -> {for (int i = 0; i < 100; i++) {System.out.println(Thread.currentThread().getName() + "线程执行了" + i + "次");
        }
    }).start();}
}

3. 实现 Callable 接口

实现 Callable 接口
创立 Callable 对象，传入 FutureTask 对象
创立 Thread 对象，FutureTas 对象
启动线程

// 实现 call 办法
@Override
public Long call() throws Exception {
    long sum = 0;
    for (int i = 0; i < 1000000000; i++) {sum += i;}
    return sum;
}
}

public class CallableDemo {public static void main(String[] args) {
    // 创立 Callable 对象，传入 FutureTask 对象
    FutureTask<Long> task = new FutureTask<>(new MyCallable());
    // 创立 Thread 对象，传入 FutureTask 对象
    Thread thread = new Thread(task);
    // 启动线程
    thread.start();
    // 取得返回值
    try {System.out.println(task.get());
    }catch (Exception e) {e.printStackTrace();
    }
}
}

4. 通过线程池实现多线程

@Override
public void run()
{System.out.println("线程名" + Thread.currentThread().getName());

}
}

public class ThreadPollDemo {

// 线程池数量
private static int threadPoolNum = 10;

public static void main(String[] args) {ExecutorService executorService = Executors.newFixedThreadPool(5);
    for(int i = 0; i < threadPoolNum; i ++)
    {
        // 创立线程对象
        MyRunnable thread = new MyRunnable();
        executorService.execute(thread);
    }
}
}

三、线程的生命周期
1. 新建（NEW）：创立 Thread 类的实例时，线程进入新建状态。
2. 就绪（RUNNABLE）：调用线程对象的 start() 办法后，期待被调配给 CPU 工夫片、谁先抢到 CPU 资源，谁开始执行。
3. 运行（RUNNING）：当就绪的线程被调并取得度 CPU 资源时，进入运行状态，执行 run()办法中的性能。
4. 梗塞（BLOCKED）：java 培训线程运行时呈现某些起因导致正在运行的线程进入梗塞状态。
5. 死亡（DEAD）：线程执行结束或被强行终止。

四、线程的罕用办法