线程

文章线程分享给大家，欢迎收藏Java资料网，专注分享技术知识

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类

//线程的调用

public class ThreadTest extends Thread{

    public static void main(String[] args) {

        ThreadTest t=new ThreadTest();

        ThreadTest t1=new ThreadTest();

        t.start();

        t1.start();

        for(int i=0;i<3;i++){

            System.out.println("look这里:"+i+"个");

        }

    }

    public void run(){

        for(int i=0;i<10;i++){

            System.out.println("=====我是线程=="+Thread.currentThread().getName()+" ,i="+i);

        }

    }

}

执行结果

 

(2)    实现Runable接口

(3)  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();

    }

}

执行结果

 

(4)    实现Callable接口

(5)  import java.util.concurrent.Callable;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;



public class CallableTest implements Callable<Boolean> {



    /*

    实现Callable接口，需要返回值类型

    重写Call方法，需要抛出异常

    创建目标对象

    创建执行服务：ExecutorService es = Executors.newFixedThreadPool(1);

    提交执行：Future r1 = es.submit(d1);

    获取结果：Boolean res1 = r1.get();

    关闭服务：es.shutdownNow();

     */

    public static void main(String[] args) {

        CallableTest t = new CallableTest();

        ExecutorService es = Executors.newFixedThreadPool(4);

        ExecutorService es2 = Executors.newFixedThreadPool(4);

        es.submit(t);

        es2.submit(t);

    }



    @Override

    public Boolean call() throws Exception {

        for (int i = 0; i < 10; i++) {

            System.out.println("Callable线程来了" + Thread.currentThread().getName() + "===,i=" + i);

        }

        return null;

    }

}

执行结果

 

8. 多线程的优点

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

总结：

1）.提高CPU的使用率。

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

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

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

9. 多线程的缺点

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

（2）      线程活性问题，线程死锁，活锁，线程饥饿问题

（3）      上下文问题，上下文切换，增加系统消耗，CPU开销大

（4）      可靠性。

10.    并行与并发

（1）     并行

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

（2）     并发

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

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

①    竞争死锁

②    系统资源不足

③    线程泄露

④    并发错误

⑤    任务过载

 

文章来源:https://www.cnblogs.com/yutting/p/17822736.html
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系邮箱：jacktools123@163.com进行投诉反馈，一经查实，立即删除！