程序进程线程

Posted lemonzhang

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了程序进程线程相关的知识,希望对你有一定的参考价值。

1、程序(program):是为完成特定任务、用某种语言编写的一组指令的集合。即指一 段静态的代码,静态对象。

2、进程(process):是程序的一次执行过程,或是正在运行的一个程序。是一个动态的过程:有它自身的产生、存在和消亡的过程。—生命周期

  1)进程作为资源分配的单位,系统在运行时会为每个进程分配不同的内存区域

3、线程(thread),进程可进一步细化为线程,是一个程序内部的一条执行路径。

  1)若一个进程同一时间并行执行多个线程,就是支持多线程的

  2)线程作为调度和执行的单位,每个线程拥有独立的运行栈和程序计数器(pc),线程切换的开销小

  3)一个进程中的多个线程共享相同的内存单元/内存地址空间?它们从同一堆中分配对象,可以 访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患

技术图片

 

一个Java应用程序java.exe,其实至少有三个线程:main()主线程,gc() 垃圾回收线程,异常处理线程。当然如果发生异常,会影响主线程。

并行与并发: 

  1) 并行:多个CPU同时执行多个任务。比如:多个人同时做不同的事。

  2) 并发:一个CPU(采用时间片)同时执行多个任务。比如:秒杀、多个人做同一件事。

多线程程序的优点:

  1) 提高应用程序的响应。对图形化界面更有意义,可增强用户体验。

  2) 提高计算机系统CPU的利用率

  3) 改善程序结构。将既长又复杂的进程分为多个线程,独立运行,利于理解和修改

何时需要多线程

  1)程序需要同时执行两个或多个任务。

  2)程序需要实现一些需要等待的任务时,如用户输入、文件读写操作、网络操作、搜索等。

  3)需要一些后台运行的程序时。

线程的创建和启动

Java语言的JVM允许程序运行多个线程,它通过java.lang.Thread 类来体现。

  1)每个线程都是通过某个特定Thread对象的run()方法来完成操作的,经常把run()方法的主体称为线程体

  2)通过该Thread对象的start()方法来启动这个线程,而非直接调用run()。

Thread类构造器

  1)Thread():创建新的Thread对象;

  2)Thread(String threadname):创建线程并指定线程实例名;

  3)Thread(Runnable target):指定创建线程的目标对象,它实现了Runnable接 口中的run方法;

  4)Thread(Runnable target, String name):创建新的Thread对象。


 

API中创建线程的两种方式

JDK1.5之前创建新执行线程有两种方法:

  1)继承Thread类的方式;

  2)实现Runnable接口的方式;

1):继承Thread类

1)  定义子类继承Thread类。 
2)  子类中重写Thread类中的run方法。
3)  创建Thread子类对象,即创建了线程对象。 
4)  调用线程对象start方法:启动线程,调用run方法。
package com.thread.test;

public class ThreadTest {
    public static void main(String[] args) {
        //3 创建Thread子类对象,即创建了线程对象。 
        MyThread m=new MyThread();
        //4 调用线程对象start方法:启动线程,调用run方法。
        m.start();
    }
}
//1 定义子类继承Thread类。
class  MyThread extends  Thread{
    //2 子类中重写Thread类中的run方法。
    @Override
    public  void  run(){
        for (int i = 0; i <100 ; i++) {
            System.out.println("子线程"+i);
        }
    }
}

2):实现Runnable接口

1) 定义子类,实现Runnable接口。 
2) 子类中重写Runnable接口中的run方法。 
3) 通过Thread类含参构造器创建线程对象。 
4) 将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中。 
5) 调用Thread类的start方法:开启线程,调用Runnable子类接口的run方法。
package com.thread.test;

public class ThreadTest {
    public static void main(String[] args) {

//        3) 通过Thread类含参构造器创建线程对象。------------------------------创建实现类的对象
//        4) 将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中。-------将此对象作为参数传递Thread类构造器中,创建Thread类的对象
//        5) 调用Thread类的start方法:开启线程,调用Runnable子类接口的run方法。---通过Thread类的对象调用start();
        new Thread(new MyThread2()).start();
    }
}

    // 1) 定义子类,实现Runnable接口。
class  MyThread2 implements  Runnable{
    //2) 子类中重写Runnable接口中的run方法。
    @Override
    public void run() {
        for (int i = 0; i <100 ; i++) {
            System.out.println("子线程"+i);
        }
    }
}

Thread类的有关方法

void start():  启动线程,并执行对象的run()方法 ?
run():  线程在被调度时执行的操作 ?
String getName():  返回线程的名称 ?
void setName(String name):设置该线程名称 ?
static Thread currentThread(): 返回当前线程。在Thread子类中就是this,通常用于主线程和Runnable实现类
static  void  yield():线程让步 ?
  暂停当前正在执行的线程,把执行机会让给优先级相同或更高的线程 ?
  若队列中没有同优先级的线程,忽略此方法 ?
join() :当某个程序执行流中调用其他线程的 join() 方法时,调用线程将 被阻塞,直到 join() 方法加入的 join 线程执行完为止 ?
  低优先级的线程也可以获得执行 ?
static  void  sleep(long millis):(指定时间:毫秒) ?
  令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后 重排队。 ?
  抛出InterruptedException异常 ?
stop(): 强制线程生命期结束,不推荐使用 ?
boolean isAlive():返回boolean,判断线程是否还活着

线程的调度

1)调度策略

技术图片

2)调度方法

  1.同优先级线程组成先进先出队列(先到先服务),使用时间片策略

  2.对高优先级,使用优先调度的抢占式策略

3)线程的优先级

  1.等级,方法

MAX_PRIORITY:10 ?
MIN _PRIORITY:1 ?
NORM_PRIORITY:5 
getPriority() :返回线程优先值 ?
setPriority(int newPriority) :改变线程的优先级

  线程创建时继承父线程的优先级 ?

  低优先级只是获得调度的概率低,并非一定是在高优先级线程之后才被调用

  Java中的线程分为两类:一种是守护线程,一种是用户线程。

  守护线程是用来服务用户线程的,通过在start()方法前调用 thread.setDaemon(true)可以把一个用户线程变成一个守护线程。

  Java垃圾回收就是一个典型的守护线程。


线程的生命周期

技术图片

技术图片

多线程出现了安全问题

  当多条语句在操作同一个线程共享数据时,一个线程对多条语句只执行了一部分,还没有 执行完,另一个线程参与进来执行。导致共享数据的错误。

  对多条操作共享数据的语句,只能让一个线程都执行完,在执行过程中,其他线程不可以 参与执行。

线程的同步:Synchronized同步机制

技术图片

同步机制中的锁:

在《Thinking in Java》中,是这么说的:对于并发工作,你需要某种方式来防 止两个任务访问相同的资源(其实就是共享资源竞争)。 防止这种冲突的方法 就是当资源被一个任务使用时,在其上加锁。第一个访问某项资源的任务必须 锁定这项资源,使其他任务在其被解锁之前,就无法访问它了,而在其被解锁 之时,另一个任务就可以锁定并使用它了。

 synchronized的锁是什么? ?

  任意对象都可以作为同步锁。

  所有对象都自动含有单一的锁(监视器)。 ?

  同步方法的锁:静态方法(类名.class)、非静态方法(this) ?

  同步代码块:自己指定,很多时候也是指定为this或类名.class

必须确保使用同一个资源的多个线程共用一把锁,这个非常重要,否则就 无法保证共享资源的安全 ?

  1)同步方法仍然涉及到同步监视器,只是不需要我们显式的声明。一个线程类中的所有静态方法共用同一把锁(类名.class),所有非静态方法共用同一把锁(this),

  2)同步代码块(指定需谨慎)。对于实现 Runnable 接口的方法,由于就一个实现类对象,所以可以用this 当锁。 对于继承Thread 类的方法,由于有多个子类的实例,所以需要使用 类名.class 当锁。

同步的方式,解决了线程的安全问题。---好处

操作同步代码时,只能有一个线程参与,其他线程等待。相当于是一个单线程的过程,效率低。 ---局限性

技术图片技术图片

技术图片

线程的通信:

* 涉及到的三个方法:
* wait():一旦执行此方法,当前线程就进入阻塞状态,并释放同步监视器。
* notify():一旦执行此方法,就会唤醒被wait的一个线程。如果有多个线程被wait,就唤醒优先级高的那个。
* notifyAll():一旦执行此方法,就会唤醒所有被wait的线程。
*
* 说明:
* 1.wait(),notify(),notifyAll()三个方法必须使用在同步代码块或同步方法中。
* 2.wait(),notify(),notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器。
* 否则,会出现IllegalMonitorStateException异常
* 3.wait(),notify(),notifyAll()三个方法是定义在java.lang.Object类中。
*
* 面试题:sleep() 和 wait()的异同?
* 1.相同点:一旦执行方法,都可以使得当前的线程进入阻塞状态。
* 2.不同点:1)两个方法声明的位置不同:Thread类中声明sleep() , Object类中声明wait()
* 2)调用的要求不同:sleep()可以在任何需要的场景下调用。 wait()必须使用在同步代码块或同步方法中
* 3)关于是否释放同步监视器:如果两个方法都使用在同步代码块或同步方法中,sleep()不会释放锁,wait()会释放锁。
package com.company;
// * 线程通信的例子:使用两个线程打印 1-100。线程1, 线程2 交替打印
public class Comm {
    public static void main(String[] args) {
        CommThread th=new CommThread();
        Thread t1=new Thread(th,"线程1");
        Thread t2=new Thread(th,"线程2");

        t1.start();
        t2.start();
    }
}


class CommThread implements Runnable{
    private  int count=100;
    private  Object ob=new Object();
    @Override
    public void run() {
        while (true)
        {
           synchronized (ob)
           {
               ob.notify();
               if(count>0)
               {
                   System.out.println("xincheng"+Thread.currentThread().getName()+":"+count);
                   count--;
                   try {
                       ob.wait();
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               }
               else
               {
                   break;
               }
           }
        }
    }
}
* 解决线程安全问题的方式三:Lock锁  --- JDK5.0新增
*
* 1. 面试题:synchronized 与 Lock的异同?
* 相同:二者都可以解决线程安全问题
* 不同:synchronized机制在执行完相应的同步代码以后,自动的释放同步监视器
* Lock需要手动的启动同步(lock()),同时结束同步也需要手动的实现(unlock())
*
* 2.优先使用顺序:
* Lock ? 同步代码块(已经进入了方法体,分配了相应资源) ? 同步方法(在方法体之外)
*
*
* 面试题:如何解决线程安全问题?有几种方式

技术图片

package com.company;

import java.util.concurrent.locks.ReentrantLock;

public class MainLock {
    public static void main(String[] args) {
        Test th=new Test();
        Thread t1=new Thread(th,"窗口1");
        Thread t2=new Thread(th,"窗口2");
        Thread t3=new Thread(th,"窗口3");

        t1.start();
        t2.start();
        t3.start();
    }


}


class  Test implements Runnable{
    private  int ticket=100;
    ////1.实例化ReentrantLock
    private ReentrantLock Lock=new ReentrantLock();
    @Override
    public void run() {
        while (true)
        {
            ////2.调用锁定方法lock()
                Lock.lock();
            try {
                {
                    if(ticket>0){
                        System.out.println(Thread.currentThread().getName()+"买票:"+ticket);
                        ticket--;
                    }
                    else {
                        break;
                    }
                }
            } finally {
                // //3.调用解锁方法:unlock()
                Lock.unlock();
            }

        }
    }
}
package com.company;
/* * 线程通信的应用:经典例题:生产者/消费者问题
         *
         * 生产者(Productor)将产品交给店员(Clerk),而消费者(Customer)从店员处取走产品,
         * 店员一次只能持有固定数量的产品(比如:20),如果生产者试图生产更多的产品,店员
         * 会叫生产者停一下,如果店中有空位放产品了再通知生产者继续生产;如果店中没有产品
         * 了,店员会告诉消费者等一下,如果店中有产品了再通知消费者来取走产品。
         *
         * 分析:
         * 1. 是否是多线程问题?是,生产者线程,消费者线程
         * 2. 是否有共享数据?是,店员(或产品)
         * 3. 如何解决线程的安全问题?同步机制,有三种方法
         * 4. 是否涉及线程的通信?是*/
public class Product {
    public static void main(String[] args) {
        Clerk clerk=new Clerk();

        Producer p1=new Producer(clerk);
        Consumer c1=new Consumer(clerk);

        p1.start();
        c1.start();
    }
}

//共享数据可以认为是Clerk或者producecount
class Clerk{
    private int producecount=0;

    public synchronized void produceProduct(){
        if(producecount<20)
        {
            producecount++;
            System.out.println(Thread.currentThread().getName()+":生产"+producecount);

            notify();
        }
        else
        {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public synchronized void comsumProduct(){
        if(producecount>0)
        {
            producecount--;
            System.out.println(Thread.currentThread().getName()+":消费"+producecount);

            notify();
        }
        else
        {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

//生产者线程
class  Producer extends  Thread{
    private Clerk clerk;

    public Producer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println(getName() + ":开始生产产品.....");
        while (true)
        {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.produceProduct();
        }
    }
}

//消费者的线程
class  Consumer extends Thread{
    private  Clerk clerk;

    public Consumer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println(getName() + ":开始消费产品.....");
        while (true)
        {
            try {
                Thread.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.comsumProduct();
        }
    }
}
* 创建线程的方式三:实现Callable接口。 --- JDK 5.0新增
*
*
* 如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大?
* 1. call()可以有返回值的。
* 2. call()可以抛出异常,被外面的操作捕获,获取异常的信息
* 3. Callable是支持泛型的
//1.创建一个实现Callable的实现类
class NumThread implements Callable{
    //2.实现call方法,将此线程需要执行的操作声明在call()中
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if(i % 2 == 0){
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}


public class ThreadNew {
    public static void main(String[] args) {
        //3.创建Callable接口实现类的对象
        NumThread numThread = new NumThread();
        //4.将此Callable接口实现类的对象作为传递到FutureTask构造器中,创建FutureTask的对象
        FutureTask futureTask = new FutureTask(numThread);
        //5.将FutureTask的对象作为参数传递到Thread类的构造器中,创建Thread对象,并调用start()
        new Thread(futureTask).start();

        try {
            //6.获取Callable中call方法的返回值
            //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
            Object sum = futureTask.get();
            System.out.println("总和为:" + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

}
* 创建线程的方式四:使用线程池
*
* 好处:
* 1.提高响应速度(减少了创建新线程的时间)
* 2.降低资源消耗(重复利用线程池中线程,不需要每次都创建)
* 3.便于线程管理
* corePoolSize:核心池的大小
* maximumPoolSize:最大线程数
* keepAliveTime:线程没有任务时最多保持多长时间后会终止
class NumberThread implements Runnable{

    @Override
    public void run() {
        for(int i = 0;i <= 100;i++){
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}

class NumberThread1 implements Runnable{

    @Override
    public void run() {
        for(int i = 0;i <= 100;i++){
            if(i % 2 != 0){
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}

public class ThreadPool {

    public static void main(String[] args) {
        //1. 提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
        //设置线程池的属性
//        System.out.println(service.getClass());
//        service1.setCorePoolSize(15);
//        service1.setKeepAliveTime();


        //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread());//适合适用于Runnable
        service.execute(new NumberThread1());//适合适用于Runnable

//        service.submit(Callable callable);//适合使用于Callable
        //3.关闭连接池
        service.shutdown();
    }

}

 

参考

 

以上是关于程序进程线程的主要内容,如果未能解决你的问题,请参考以下文章

多线程编程

python多线程

多个请求是多线程吗

[Python3] 043 多线程 简介

进程和线程和协程之间的关系

线程