基本概念：程序、进程、线程
-
程序：是为完成特定任务、用某种语言编写的一组指令的集合。即指一
段静态的代码。
-
进程：是程序的一次执行过程，或是正在运行的一个程序
-
线程：进程可进一步细化为线程，是一个程序内部的一条执行路径。
一个Java应用程序java.exe，其实至少有三个线程：main()主线程，gc()垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。
基本概念：并行与并发
- 并行：多个CPU同时执行多个任务。比如：团队多人同时开发一个项目不同模块
- 并发：一个CPU(采用时间片)同时执行多个任务。比如：商城秒杀
为什么使用多线程（多线程优点）
- 提高应用程序的响应。对图形化界面更有意义，可增强用户体验。比如：电脑管家可以同时病毒查杀、扫描垃圾、电脑加速等等。
- 提高计算机系统CPU多核的利用率。
- 改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和
修改
多线程的创建（四种方式）
方式一： 继承Thread类，重写Thread类的run()
Thread 类
package java.lang;
public class Thread implements Runnable {
// Thread 类的构造方法
public Thread(Runnable target);
public Thread(Runnable target, String name);
}
例子
class MyThread extends Thread{
@Override
public void run() {
System.out.println("这里是继承Thread的方式创建线程");
}
}
public class Test {
public static void main(String[] args) {
new MyThread().start();
}
}
方式二：实现Runnable接口中的run()
Runnable 函数式接口
package java.lang;
@FunctionalInterface
public interface Runnable {
pubic abstract void run();
}
例子
public class Test {
public static void main(String[] args) {
new Thread(new MyRunnable()).start();
// 匿名内部类的写法
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "\t" + Thread.currentThread().getId());
}
}).start();
//根据Lambda表达式的变种写法
new Thread(()-> System.out.println("Lambda方式")).start();
}
}
class MyRunnable implements Runnable{
@Override
public void run() {
System.out.println("这里是实现Runnable接口的方式创建线程");
}
}
比这两种较创建线程的两种方式
开发中：优先选择：实现Runnable接口的方式
原因：
-
实现的方式没有类的单继承性的局限性
-
实现的方式更适合来处理多个线程有共享数据的情况。
相同点：两种方式都需要重写run()，将线程要执行的逻辑声明在run()中。
注意事项：
- 不能通过直接调用run()的方式启动线程，这样调用无法启动子线程
- 不能连续调用两次start()，需要重新创建一个线程的对象
方式三： 实现Callable接口中的call() – jdk5新增
Callable 也是一种函数式接口
- 需要借助FutureTask类，可以获取返回值
- 可以抛出异常
- 支持泛型
@FunctionalInterface
public interface Callable<V> {
V call() throws Exception;
}
例子
public class Test {
public static void main(String[] args) {
FutureTask<String> futureTask = new FutureTask(new MyCallable());
new Thread(futureTask).start();
try {
String str = futureTask.get();
System.out.println(str);
} catch (Exception e) {
e.printStackTrace();
}
}
}
class MyCallable implements Callable<String> {
@Override
public String call() throws Exception {
return "这里是实现Callable接口的方式创建线程";
}
}
方式四： 使用线程池 – jdk5新增
好处：
-
提高响应速度（减少了创建新线程的时间）
-
降低资源消耗（重复利用线程池中线程，不需要每次都创建）
-
便于线程管理
ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
-
void execute(Runnable command) ：执行任务/命令，没有返回值，一般用来执行Runnable
-
<T> Future<T> submit(Callable task)：执行任务，有返回值，一般又来执行Callable
-
void shutdown() ：关闭连接池
Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
-
Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池
-
Executors.newFixedThreadPool(n); 创建一个可重用固定线程数的线程池
-
Executors.newSingleThreadExecutor() ：创建一个只有一个线程的线程池
-
Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运
行命令或者定期地执行。
public class TestPool {
public static void main(String[] args) {
//1. 提供指定线程数量的线程池
ExecutorService service = Executors.newFixedThreadPool(10);
ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
//设置线程池的属性
// service1.setCorePoolSize(15);
// service1.setKeepAliveTime();
Future<String> futureTask = service.submit(new MyCallable());//submit适合使用于Callable
try {
System.out.println(futureTask.get());
} catch (Exception e) {
e.printStackTrace();
}
service.execute(new MyRunnable());//execute适合适用于Runnable
service.shutdown();
}
}
class MyCallable implements Callable<String> {
@Override
public String call() throws Exception {
return "这里是用Callable接口的方式创建线程池";
}
}
class MyRunnable implements Runnable{
@Override
public void run() {
System.out.println("这里是用Runnable接口的方式创建线程池");
}
}
Thread类的有关方法
-
start()：启动当前线程；调用当前线程的run()
-
run()：通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
-
currentThread()：静态方法，返回执行当前代码的线程
-
getName()：获取当前线程的名字
-
setName()：设置当前线程的名字
-
yield()：线程礼让，释放当前cpu的执行权，cpu重新选择线程执行
-
join()：在线程a中调用线程b的join(),此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态。
-
stop()：已过时。当执行此方法时，强制结束当前线程。 -
sleep(long millitime)：让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内，当前线程是阻塞状态。
-
isAlive()：判断当前线程是否存活
-
线程的优先级：
MAX_PRIORITY：10
MIN _PRIORITY：1
NORM_PRIORITY：5 -->默认优先级
如何获取和设置当前线程的优先级：
getPriority()：获取线程的优先级
setPriority(int p)：设置线程的优先级
说明：高优先级的线程要抢占低优先级线程cpu的执行权。但是只是从概率上讲，高优先级的线程高概率的情况下被执行。并不意味着只有当高优先级的线程执行完以后，低优先级的线程才执行。
方法在代码中的使用
class MyThread extends Thread{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
try {
//线程休眠10毫秒
sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
//获取当前线程的名字，获取线程的优先级
System.out.println(Thread.currentThread().getName() + ":" + Thread.currentThread().getPriority() + ":" + i);
if(i % 20 == 0){
//线程礼让
yield();
}
}
}
}
public class ThreadMethodTest {
public static void main(String[] args) {
MyThread m1 = new MyThread();
//给分线程命名
m1.setName("线程一");
//设置分线程的优先级
m1.setPriority(Thread.MAX_PRIORITY);
//启动当前线程
m1.start();
//给主线程命名
Thread.currentThread().setName("主线程");
//设置线程的优先级
Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
for (int i = 0; i < 100; i++) {
//获取当前线程的名字，获取线程的优先级
System.out.println(Thread.currentThread().getName() + ":"+Thread.currentThread().getPriority()+ ":" + i);
if(i == 20){
try {
//被调用线程获得优先执行完成的权利
m1.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
//判断线程是否存活
System.out.println(m1.isAlive());
}
}
线程的分类
Java中的线程分为两类：一种是守护线程，一种是用户线程。
-
它们在几乎每个方面都是相同的，唯一的区别是判断JVM何时离开。
- 当线程只剩下守护线程的时候，JVM 就会退出；守护线程在结束其余的子线程自动关闭
-
如果还有其他的任意一个用户线程还在，JVM 就不会退出。
-
守护线程是用来服务用户线程的，通过在start()方法前调用**thread.setDaemon(true)**可以把一个用户线程变成一个守护线程。
-
Java垃圾回收就是一个典型的守护线程。
-
若JVM中都是守护线程，当前JVM将退出。
-
它们在几乎每个方面都是相同的，唯一的区别是判断JVM何时离开。
- 当线程只剩下守护线程的时候，JVM 就会退出；守护线程在结束其余的子线程自动关闭
-
如果还有其他的任意一个用户线程还在，JVM 就不会退出。
-
守护线程是用来服务用户线程的，通过在start()方法前调用**thread.setDaemon(true)**可以把一个用户线程变成一个守护线程。
-
Java垃圾回收就是一个典型的守护线程。
-
若JVM中都是守护线程，当前JVM将退出。
线程生命周期
JDK中用Thread.State类定义了线程的几种状态
要想实现多线程，必须在主线程中创建新的线程对象。Java语言使用Thread类及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下的五种状态：
- 新建： 当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
- 就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源
- 运行：当就绪的线程被调度并获得CPU资源时,便进入运行状态， run()方法定义了线程的操作和功能
- 阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行，进入阻塞状态
- 死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束
9148
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
