Java 程序设计 第八章 线程

简介: Java 程序设计 第八章 线程

第8章 线程

线程可以让一个程序同时执行多个任务,在实际程序应用地非常广泛。

8.1 理解线程

8.1.1进程的概念

了解线程前先了解一下进程,进程可以看成是程序的执行,可以把一个程序的执行过程看成是一个进程。

比如我们打开一个Word程序,就有一个Word程序进程。

8.1.2 线程的概念(此处是个人理解。)

一个进程可以有多个线程,同时执行多个任务。同样用Word举例,Word显示可以看成是一个线程,编辑可以看出是一个线程。

8.1.3 线程的生命周期

线程的生命周期有4种基本状态:

1.产生

2.中断

3.非中断(运行或可运行)

4.退出

8.2 线程类设计

8.2.1 线程API类图

Thread类是线程实现的主类,其核心过程方法由Runnable接口规范。

 

8.2.2  线程类Thread的构造方法

1.Thread(String threadName);  //创建指定名称的线程类

2.Thread();                              //线程类名称系统自动指定Thread-编号

3.Thread(Runnable target)  //target为目标对象,target需要实现Runnable接口,给出run()方法。

8.3 线程实现

线程的实现一般有两种方式:

(1)创建Thread类的子类,并重新定义run()方法,用户只要创建子类对象就能建立自己的线程。

(2)创建实现Runnable接口的类,并实现run()方法。

8.3.1 继承实现

方式一:继承Thread类

public class ThreadDemo extends Thread{
  public void run() {
    //线程代码实现
    System.out.println("线程执行");
  }
  public static void main(String[] args) {
    ThreadDemo th = new ThreadDemo();
    th.start();
  }
}

8.3.2接口实现

方式二:实现Runnable接口

 

public class ThreadDemo2{
  public static void main(String[] args) {
    Thread th  = new Thread(new MyThImpl());
    th.start();
  }
}
class MyThImpl implements Runnable{
  public void run() {
    //线程代码实现
    System.out.println("线程执行");
  }
}

8.4 线程控制

8.4.1 监控线程状态

线程状态在枚举类型Thread.State中定义。

NEW:新创建,还没调用start()

RUNNABLE:run()中代码被执行

BLOCKED:阻塞,等待解锁

WAITING:另一个线程运行,本线程等待

TIMED_WAIYING:等待到指定时间

TERMINATED:线程退出run()

获取线程状态方法:

public Thread.State getState()

 

8.4.2 线程休眠

Thread的sleep()方法

public class sleep1 {
  public static void main(String[] args) throws InterruptedException {
    for(int i=0;i<20;i++) {
      System.out.println("main"+i);
      Thread.sleep(1000);
    }
  }
}

注意:(1)sleep是静态方法,睡眠的是当前运行的线程、

 

8.4.3 中断线程

public void interrupt() :中断当前阻塞与等待状态,强制线程抛出异常。

 

8.4.4 阻塞进程 join()

void join(): 当前线程等待加入该线程后面,等待该线程终止

void join(long millis):当前线程等待该线程终止的时间最长为millis毫秒,如果超时还没执行完,当前线程也会进入就绪状态。

void join(long millis, int nanos);等待时间millis毫秒+nanos纳秒

8.4.5线程等待和唤醒

public final void wait() throws InterruptedException
public final void wait(long timeout,int nanos)throws InterruptedException
void notify()
void notifyAll()

如果线程等待用sleep(),唤醒用interrupt()

等待用join(),唤醒用interrupt()

等待用wait(),唤醒用notify();

 

8.4.6线程终止

当前线程放弃调度执行权力,等待下次排队执行。

public static void yield()

 

..线程控制综合实例

 

import java.util.Scanner;
public class sleep1 {
  private static int data = -1;
  private static Thread thread = new Thread(new Runnable() {
    public void run() {
      System.out.println("线程已经启动,输入0开始计数");
      for(int i=10;i>0;i--) {
        while(data != 0) {
          Thread.yield();
        }
        System.out.println(Thread.currentThread().getName()+":"+i);
        try {
          Thread.sleep(100);
        }catch(InterruptedException e) {
          e.printStackTrace();
        }
        
      }
    }
  });
  public static void main(String[] args) {
    thread.start();
    Scanner in = new Scanner(System.in);
    while(data == -1) {
      try {
        data=Integer.parseInt(in.nextLine());
        if(data!=0) {
          System.out.println("enter 0 to start counting");
          data = -1;
        }
      }catch(NumberFormatException e) {
        System.out.println("请输入整数");
      }
    }
  in.close(); 
  }
}
 
 
 

8.5 线程属性

8.5.1 优先级

优先级较高的线程获取CPU资源的概率较大。

每个线程默认的优先级和父线程相同。

Thread类提供setPriority(int newPriority和getPriority)和getPriority()方法来设置和得到优先级。

setPriority的参数时一个整数,范围1~10. (10最高)。

优先级实例:

 
public class priority1 {
  public static void main(String[] args) {
    new MyThread("低级",1).start();
    new MyThread("高级",10).start();
  }
}
class MyThread extends Thread{
  public MyThread(String name,int pro) {
    super(name);
    setPriority(pro);
  }
  public void run() {
    for(int i=0;i<=100;i++) {
      System.out.println(this.getName()+"线程第"+i+"次执行");
    }
  }
}

多次运行可以发现,多数情况下优先级高的先运行完成。

8.5.2 守护线程

Java中有两类线程:用户线程User Thread 和 守护线程Daemon Thread

守护线程具有最低优先级,为系统其它对象提供服务。

一般不会自己操作守护进程。

 

8.6线程同步

8.6.1Synchronized同步方法和同步代码块

保护某段代码只能同时被一个线程执行的技术成为线程同步。

关键字synchronized是Java内部实现的一个简单锁,可以用synchronized锁定一段代码:

public static void biz() {
    synchronized(Object.class) {
      a++;
      b++;
      if(a!=b) {
        System.out.println(a+"!="+b);
      }
    }
  }

或者锁定整个方法:

  synchronized public static void biz() {
      a++;
      b++;
      if(a!=b) {
        System.out.println(a+"!="+b);
      }
    
  }

8.6.2 同步变量volatile关键字

Java变量前可以加修饰语volatile,volatile的主要目的是解决成员变量的多线程访问同步问题。

在读取加了volatie修饰的变量时,会直接从内存读取。

但volatile不保证对变量的操作是原子操作。

Java提供java.util.concurrent.automic包,提供了基本类型与引用类型的原子性操作封装类:

AtomicBoolean

AtomicInteger

AtomicIntegerArray

...

 

8.6.3线程锁Lock接口及ReentrantLock类

8.6.4 死锁

不同线程都在等待那些不可能被释放的锁时,就成了死锁。

构成死锁的典型是锁交叉。


相关文章
|
2天前
|
存储 安全 Java
Java面试题:请解释Java内存模型(JMM)是什么,它如何保证线程安全?
Java面试题:请解释Java内存模型(JMM)是什么,它如何保证线程安全?
31 13
|
2天前
|
缓存 安全 Java
Java中线程池如何管理?
【7月更文挑战第11天】Java中线程池如何管理?
8 2
|
2天前
|
安全 算法 Java
Java中线程安全怎么做?
【7月更文挑战第11天】Java中线程安全怎么做?
9 2
|
1天前
|
存储 安全 算法
深入理解Java并发编程:线程安全与性能优化
【5月更文挑战第72天】 在现代软件开发中,尤其是Java应用开发领域,并发编程是一个无法回避的重要话题。随着多核处理器的普及,合理利用并发机制对于提高软件性能、响应速度和资源利用率具有重要意义。本文旨在探讨Java并发编程的核心概念、线程安全的策略以及性能优化技巧,帮助开发者构建高效且可靠的并发应用。通过实例分析和理论阐述,我们将揭示在高并发环境下如何平衡线程安全与系统性能之间的关系,并提出一系列最佳实践方法。
|
2天前
|
Java 调度
Java线程的六种状态
Java线程有六种状态: 初始(NEW)、运行(RUNNABLE)、阻塞(BLOCKED)、等待(WAITING)、超时等待(TIMED_WAITING)、终止(TERMINATED)。
13 1
|
2天前
|
监控 Java 调度
Java面试题:描述Java线程池的概念、用途及常见的线程池类型。介绍一下Java中的线程池有哪些优缺点
Java面试题:描述Java线程池的概念、用途及常见的线程池类型。介绍一下Java中的线程池有哪些优缺点
15 1
|
17小时前
|
Java 调度
java中线程的6种状态
java中线程的6种状态
|
2天前
|
Java 调度
Java面试题:简述Java线程的生命周期及其状态转换。
Java面试题:简述Java线程的生命周期及其状态转换。
7 0
|
2天前
|
缓存 Java
Java面试题:描述Java中的线程池及其实现方式,详细说明其原理
Java面试题:描述Java中的线程池及其实现方式,详细说明其原理
5 0
|
2天前
|
设计模式 安全 Java
Java面试题:解释单例模式的实现方式及其优缺点,讨论线程安全性的实现。
Java面试题:解释单例模式的实现方式及其优缺点,讨论线程安全性的实现。
8 0