线程

1. 什么是线程

线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中,是进程中的实际运作单位。

线程是独立调度和分派的基本单位。

2. 线程的特点

(1)轻量实体:线程中实体基本上不拥有系统资源,只是有一点必不可少的、能保证独立运行的资源。

(2)独立调度和分派的基本单位:在多线程操作系统中,线程是能够独立运行的基本单位,因而也是独立调度和分派的基本单位。由于线程很轻,故线程的切换飞叉昂迅速且开销小。

(3)可并发执行:在一个进程中的多个线程之间,可以并发执行,甚至允许在一个进程张红所有线程都能并发执行。

(4)共享进程资源:在同一进程中的各个线程,都可以共享该进程所拥有的资源,所有线程都具有相同的地址空间,线程可以访问改地址空间的每一个虚地址,同一个进程内的线程共享内存和文件,所以线程之间互相通信不必调用内核

3. 什么是多线程

同一时刻只允许执行一个的线程叫单线程;则同一时刻,可以执行多个线程称为多线程。

4. 为什么要使用多线程

(1)      为了更好的利用CPU资源

(2)      进程之间不能共享数据,线程可以

(3)      系统创建进程需要重新分配系统资源,创建线程的代价比较小。

(4)      Java语言内置了多线程功能支持,简化了java多线程编程。

5. 多线程的应用场景

定时任务,监听器,记录日志,数据导入,模拟高并发,统计数据等

6. 线程的生命周期

新建 ->就绪->运行->阻塞->终止

新建:new 一个线程对象(初始化)

就绪:Runable,当调用start()方法,线程即进入就绪状态。这个状态的线程位于可运行池,等待获取CPU使用权。

运行:Runing ,当就绪状态的线程获得了CPU执行资源,执行run()代码则称为运行状态。

阻塞:阻塞状态,指运行中的线程,由于某些原因放弃对CPU的使用权,处于阻塞状态,直到其进入就绪状态,才有机会再次被CPU调用进入运行状态。

等待阻塞(wait()),同步阻塞(获取同步锁失败),其他阻塞(sleep(),join(),或者I/O请求)

终止:正常结束,线程执行完成(interrupt()会抛出异常,break跳出循环,stop()会死锁,线程不安全)

7. 线程的实现方式

(1)    继承Thread类

 1 //线程的调用
 2 
 3 public class ThreadTest extends Thread{
 4     public static void main(String[] args) {
 5         ThreadTest t=new ThreadTest();
 6         ThreadTest t1=new ThreadTest();
 7         t.start();
 8         t1.start();
 9         for(int i=0;i<3;i++){
10             System.out.println("look这里:"+i+"个");
11         }
12     }
13     public void run(){
14         for(int i=0;i<10;i++){
15             System.out.println("=====我是线程=="+Thread.currentThread().getName()+" ,i="+i);
16         }
17     }
18 }

 

执行结果

 

(2)    实现Runable接口

public class RunnableTest implements Runnable {
    @Override
    public void run() {
        for(int i=0;i<10;i++){
            System.out.println("线程来了"+Thread.currentThread().getName()+"===,i="+i);
        }
    }
/*
    定义MyRunnable类实现Runnable接口
    实现run()方法,编写线程执行体
    创建线程对象,调用start()方法启动线程
 */
    public static void main(String[] args) {
        RunnableTest t=new RunnableTest();
        new Thread(t,"线程1").start();
        new Thread(t,"线程2").start();
    }
}

执行结果

 

(3)    实现Callable接口

 1 import java.util.concurrent.Callable;
 2 import java.util.concurrent.ExecutorService;
 3 import java.util.concurrent.Executors;
 4 
 5 public class CallableTest implements Callable<Boolean> {
 6     /*
 7     实现Callable接口,需要返回值类型
 8     重写Call方法,需要抛出异常
 9     创建目标对象
10     创建执行服务:ExecutorService es = Executors.newFixedThreadPool(1);
11     提交执行:Future r1 = es.submit(d1);
12     获取结果:Boolean res1 = r1.get();
13     关闭服务:es.shutdownNow();
14      */
15     public static void main(String[] args) {
16         CallableTest t = new CallableTest();
17         ExecutorService es = Executors.newFixedThreadPool(4);
18         ExecutorService es2 = Executors.newFixedThreadPool(4);
19         es.submit(t);
20         es2.submit(t);
21     }
22 
23     @Override
24     public Boolean call() throws Exception {
25         for (int i = 0; i < 10; i++) {
26             System.out.println("Callable线程来了" + Thread.currentThread().getName() + "===,i=" + i);
27         }
28         return null;
29     }
30 }

 

执行结果

 

8. 多线程的优点

前面有提到为什么要使用多线程,这也是多线程的亮点及优点

总结:

1).提高CPU的使用率。

2).提高响应性,响应速度快。在使用多线程的情况下,一个请求因为网络延迟得不到满足时,不影响其他 请求。

3).充分利用多核处理器资源,节约资源。

4).最小化对系统资源的利用,一个进程中的多个线程可以共享所在的进程资源。

9. 多线程的缺点

(1)      线程安全问题,当多个线程共享数据时,如果没有采取相应的并发访问措施,那么就可以能产生数据一致性问题。

(2)      线程活性问题,线程死锁,活锁,线程饥饿问题

(3)      上下文问题,上下文切换,增加系统消耗,CPU开销大

(4)      可靠性。

10.    并行与并发

(1)     并行

多个CPU同一段时间内处理两个或两个以上的事件,多个CPU被多个线程同时执行。

(2)     并发

一个CPU同一个时间段内处理两个以上的事件,一个CPU被多个线程来回切换执行。

11.    多线程并发会引发的问题

①    竞争死锁

②    系统资源不足

③    线程泄露

④    并发错误

⑤    任务过载

 

热门相关:都市剑说   余生皆是喜欢你   绍宋   黜龙   试婚老公,用点力!