第二十章总结。。。

2023-11-30 21:52
文章标签 总结 第二十章

本文主要是介绍第二十章总结。。。,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

20.1线程简介.


20.2创建线程
2.1继承Thread类
Thread 类是java.lang包中的一个类,从这个类中实例化的对象代表线程,程序员启动一个新线程需要建立Thread 实例。Thread类中常用的两个构造方法如下:


public Thread():创建一个新的线程对象。
public Thread(String threadName):创建一个名称为threadName的线程对象。

    继承Thread 类创建一个新的线程的语法如下:

public class ThreadTest extends Thread{
}

完成线程真正功能的代码放在类的run(方法中,当一个类继承Thread类后,就可以在该类中覆盖 run()方法,将实现该线程功能的代码写入run()方法中,然后调用Thread类中的start()方法执行线程,也就是调用run()方法。
Thread 对象需要一个任务来执行,任务是指线程在启动时执行的工作,该工作的功能代码被写在 run()方法中。run()方法必须使用以下语法格式:


public void run(){
}

注意如果 start()方法调用一个已经启动的线程,系统将抛出IllegalThreadStateException异常。

2.2实现Runnable接口(单继承,所以要使用接口)
实现接口语法:

public class Thread extends  Object implements Runnable

实现Runnable接口的程序会创建一个Thread 对象,并将Runnable对象与Thread对象相关联。Thread    
类中有以下两个构造方法:


☑public Thread(Runnable target)
☑public Thread(Runnable target,String name)

这两个构造方法的参数中都存在Runnable实例,使用以上构造方法就可以将Runnable 实例与 Thread 实例相关联。
使用Runnable接口启动新的线程的步骤如下:

(1)建立Runnable 对象。
(2)使用参数为Runnable对象的构造方法创建Thread实例。(3)调用start()方法启动线程。
通过 Runnable接口创建线程时,程序员首先需要编写一个实现 Runnable接口的类,然后实例化该类的对象,这样就建立了Runnable对象;接下来使用相应的构造方法创建 Thread 实例;最后使用该实例调用Thread类中的 start()方法启动线程。

 import java.awt.Container;
 
import javax.swing.JFrame;
import javax.swing.JLabel;
 
public class SwingAndThread extends JFrame{
    int count =0;
    public SwingAndThread(){
        setBounds(300,200,250,100);    //绝对定位窗体大小与位置    
        Container container = getContentPane();    //主容器    
        container.setLayout(null);    //使窗体不使用任何布局管理器    
        lcon icon = new lmagelcon("/D20/src/1.gif");    //图标对象    
        JLabel jl = new JLabel(icon);    //显示图标的标签    
        jl.setBounds(10,10,200,50);    //设置标签的位置与大小    
        Thread t = new Thread(){    //定义匿名线程对象    
        public void run() {
        while (true) {
        jl.setBounds(count,10,200,50);    //将标签的横坐标用变量表示    
        try{
            Thread.sleep(500);    //使线程休眠 500毫秒    
        } catch (InterruptedException e){
        e.printStackTrace();}
        count += 4;    //使横坐标每次增加4    
        if (count >= 200){
        count = 10;    //当图标到达标签的最右边时,使其回到标签最左边    
        }
        }
        }
        };    t.start();    container.add(jl);    //启动线程    //将标签添加到容器中    
        setVisible(true);    //使窗体可见    
        setDefaultCloseOperation(EXIT_ON_CLOSE);    //设置窗体的关闭方式
    }
 
    public static void main(String[] args) {
        new SwingAndThread();
 
    }
 
}

20.3线程的生命周期
线程具有生命周期,其中包含7种状态,分别为出生状态、就绪状态、运行状态、等待状态、休眠状态、阻塞状态和死亡状态。出生状态就是线程被创建时处于的状态,在用户使用该线程实例调用 start()方法之前线程都处于出生状态;当用户调用start()方法后,线程处于就绪状态(又被称为可执行状态);当线程得到系统资源后就进入运行状态。
一旦线程进入可执行状态,它会在就绪与运行状态下转换,同时也有可能进入等待、休眠、阻塞或死亡状态。当处于运行状态下的线程调用Thread类中的wait()方法时,该线程便进入等待状态,进入等待状态的线程必须调用Thread类中的notify0方法才能被唤醒,而调用notifyAl1O)方法可将所有处于等待状态下的线程唤醒;当线程调用Thread类中的sleep(方法时,则会进入休眠状态。如果一个线程在运行状态下发出输入/输出请求,该线程将进入阻塞状态,在其等待输入/输出结束时线程进入就绪状态,对于阻塞的线程来说,即使系统资源空闲,线程依然不能回到运行状态。当线程的run()方法执行完毕时,线程进入死亡状态。
说明
使线程处于不同状态下的方法会在20.4节中进行讲解,在此读者只需了解线程的多个状态即可。

20.4操作线程的方法
4.1线程的休眠
    import java.awt.*;
    import java.util.Random; import javax.swing.*;
    public class SleepMethodTest extends JFrame {
    private static Color[]color={ Color.BLACK, Color.BLUE,Color.CYAN,Color.GREEN,Color.ORANGE, Color.YELLOW, Color.RED,Color.PINK,Color.LIGHT_GRAY};//定义颜色数组
    private static final Random rand=new Random();    //创建随机对象    
    private static Color getC(){    //获取随机颜色值的方法    
    return color[(rand.nextInt(color.length))];
    }
    public SleepMethodTest() {
    Thread t = new Thread(new Runnable() {//创建匿名线程对象    
        int x=30;    Il定义初始坐标    
        int y=50;
        public void run(){
        while (true) {    //无限循环    
        try{    Thread.sleep(100);    //线程休眠 0.1秒    
        } catch (InterruptedException e){
        e.printStackTrace();
        Graphics graphics=getGraphics();    //获取组件绘图上下文对象    
        graphics.setColor(getC());    //设置绘图颜色    
        graphics.drawLine(x,y,100,y++);    //绘制直线并递增垂直坐标    
        if (y >=80) {
        y = 50;
        }
        }
        }
        });
        t.start();    //启动线程    
        }
    
        public static void main(String[]args){
        init(new SleepMethodTest(),100,100);
        }
        public static void init(JFrame frame, int width, int height){//初始化程序界面的方法
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
        frame.setSize(width, height); frame.setVisible(true);
        
    }
 
}

4.2线程的加入
使用join()方法加入线程

import java.awt.BorderLayout;
import javax.swing.*;
public class JoinTest extends JFrame {
private Thread threadA;    //定义两个线程    
private Thread threadB;
private JProgressBar progressBar = new JProgressBar();    //定义两个进度条组件    
private JProgressBar progressBar2=new JProgressBar();
public static void main(String[] args) {
    JoinTest test = new JoinTest(); test.setVisible(true);
    public JoinTest(){
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); setBounds(200,200,200,100);
        getContentPane().add(progressBar, BorderLayout.NORTH); //将进度条设置在窗体最北面 getContentPane().add(progressBar2,BorderLayout.SOUTH); //将进度条设置在窗体最南面
        progressBar.setStringPainted(true);    //设置进度条显示数字字符    
        progressBar2.setStringPainted(true);
        threadA = new Thread(new Runnable() {    //使用匿名内部类形式初始化 Thread实例    
    int count = 0;
    public void run() {    //重写 run()方法    
            while (true) {
                progressBar.setValue(++count);    //设置进度条的当前值    
                try {
                    Thread.sleep(100);    //使线程A 休眠 100毫秒    
                    threadB.join();    //使线程B调用 join()方法    
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
    }
            });
    threadA.start();    //启动线程A
    threadB= new Thread(new Runnable(){
        int count = 0;
        public void run() {
        while (true) {
        progressBar2.setValue(++count);    //设置进度条的当前值    
        try{    Thread.sleep(100);    //使线程B休眠 100 毫秒    
        } catch (InterruptedException e) {
        e.printStackTrace();
        if (count ==100)    break;    //跳出循环    
        }
        }
        });    //启动线程B    
        threadB.start();
        }
    }

 4.3线程的中断
现在提倡在r un()方法中使用无限循环的形式,然后使用一个布尔型标记控制循环的停止。
如果线程是因为使用了sleep()或 wait()方法:进入了就绪状态,可以使用Thread 类中interrupt)方法使线程离开run()方法,同时结束线程,但程序会会抛出 InterruptedException异常,用户可以在处理该异常时完成线程的中断业务处理,如终止while 循环。
下面的实例演示了某个线程使用interrupted0方法,同时程序抛出了InterruptedException异常,在异常处理时结束了while循环。在项目中,经常在这里执行关闭数据库连接和关闭Socket连接等操作。

import java.awt.BorderLayout;
import java.awt.event.*;
import javax.swing.*;
    public class InterruptedSwing extends JFrame {
        
        public InterruptedSwing(){
        JProgressBar progressBar = new JProgressBar();    //创建进度条    
        getContentPane().add(progressBar, BorderLayout.NORTH);//将进度条放置在窗体合适位置
        JButton button=new JButton("停止");
        getContentPane().add(button,BorderLayout.SOUTH);
        progressBar.setStringPainted(true);    //设置进度条上显示数字    
        Thread t = new Thread(new Runnable(){
        int count = 0; public void run() {
        while (true){
            progressBar.setValue(++count);//设置进度条的当前值
        try{ 
            Thread.sleep(100);    //使线程休眠 100毫秒    
        } catch (InterruptedException e){//捕捉InterruptedException 异常
            System.out.println("当前线程序被中断"); 
            break;}
        }
        }
        }
        );
        button.addActionListener(new ActionListener(){
        @Override
        public void actionPerformed(ActionEvent e){
        t.interrupt();    //中断线程    
        }
        });    t.start();    //启动线程    
        }
        public static void init(JFrame frame, int width, int height) {
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setSize(width, height); frame.setVisible(true);
        }
 
        public static void main(String[] args){
        init(new InterruptedSwing(),100,100);
        
    }
 
}

 4.4线程的礼让
Thread类中提供了一种礼让方法,使用 yield()方法表示,它只是给当前正处于运行状态的线程一
个提醒,告知它可以将资源礼让给其他线程    但这仅是一种暗示,没有任何一种机制保证当前线程会将资源礼让。
yield()方法使具有同样优先级的线程有过进入可执行状态的机会,在当前线程放弃执行权时会再度回到就绪状态。对于支持多任务的操作系统来说,不需要调用yield()方法,因为操作系统会为线程自动分配 CPU 时间片来执行。

20.5线程的优先级
 

public class PT implements Runnable {
    String name;
    public PT(String name) {
    this.name = name; 
    }
    @Override
    public void run() {
    String tmp= "";
    for (int i= 0; i< 50000; i++) {
    tmp +=i;
//完成5万次字符串拼接
    }
    System.out.println(name +"线程完成任务");
    }
    public static void main(String[]args){
    Thread a = new Thread(new PT("A"));
    a.setPriority(1);    //A线程优先级最小    
    Thread b = new Thread(new PT("B"));
    b.setPriority(3);
    Thread c = new Thread(new PT("C"));    
    c.setPriority(7);    
    Thread d = new Thread(new PT("D"));
    d.setPriority(10);    //D线程优先级最大    
    a.start();    
    b.start();    
    c.start();    
    d.start();    
    }
    }
 


线程的优先级可以使用setPriority()方法调整,如   果使用该方法设置的优先级不在1~10,将产生  IllegalArgumentException 异常。   

20.6线程同步
在单线程程序中,每次只能做一件事情,后面的事情需要等待前面的事情完成后才可以进行,但是如果使用多线程程序,就会发生两个线程抢占资源的问题,如两个人同时说话、两个人同时过同一个独木桥等。所以,在多线程编程中需要防止这些资源访问的冲突。Java提供了线程同步的机制来防止资源访问的冲突。


6.1 线程安全

实际开发中,使用多线程程序的情况很多,在编写多线程程序时,应该考虑到线程安全问题,实质上线程安全问题来源于两个线程同时存取单一对象的数据。

 
    public class ThreadSafeTest implements Runnable {
        //设置当前总票数
        int num = 10;
        public void run() {
        //设置无限循环
        while (true) {
        if (num > 0){    //判断当前票数是否大于0    
        try {
        Thread.sleep(100);    //使当前线程休眠100毫秒    
        } catch (InterruptedException e) {
            e.printStackTrace();
            }
        System.out.println(Thread.currentThread().getName()+ "----票数"+ num--);//票数减1
        }
    }
    }
        public static void main(String[]args){
        ThreadSafeTest t= new ThreadSafeTest();    //实例化类对象    
        Thread tA = new Thread(t,"线程一");    //以该类对象分别实例化4个线程    
        Thread tB = new Thread(t,"线程二"); Thread tC = new Thread(t,"线程三"); Thread tD= new Thread(t,"线程四");
        tA.start();    //分别启动线程    
        tB.start(); 
        tC.start();
        tD.start();
        }
}

从这个结果可以看出,最后打印出的剩下的票数为负值,这样就出现了问题。这是由于同时创建了4个线程,这4个线程执行run()方法,在num变量为1时,线程一、线程二、线程三、线程四都对num 变量有存储功能,当线程一执行run()方法时,还没有来得及做递减操作,就指定它调用sleep()方法进入就绪状态,统等。这种多线程的    这时线程二、线程三和线程四也都进入了run()方法,发现num 变 如果大于0则执行    量依然大于 0,但此时线程一休眠时间已到,将num变量值递减张票),第一个线程    同时线程二、线程三、线程四也都对num变量进行递减操作,从 而产生了负值。

6.2线程同步机制
1.同步块
Java 中提供了同步机制,可以有效地防止资源冲突。同步机制使用synchronized关键字, 
 语法如下: 

   
synchronized (Object){
}

通常将共享资源的操作放置在synchronized定义的区域内,这样当其他线程获取到这个锁时,就必须等待锁被释放后才可以进入该区域。Object为任意一个对象,每个对象都存在一个标志位,并具有两个值,分别为0和1。一个线程运行到同步块时首先检查该对象的标志位,如果为0状态,表明此同步块内存在其他线程,这时当期线程处于就绪状态,直到处于同步块中的线程执行完同步块中的代码后,这时该对象的标识位设置为1,当期线程才能开始执行同步块中的代码,并将Object对象的标识位设置为0,以防止其他线程执行同步块中的代码。

public class SynchronizedTest implements Runnable { 
    int num = 10;
 
//设置当前总票数
    public void run() {
        while (true){    //设置无限循环    
            synchronized (this){    //设置同步代码块    
                if (num > 0) {    //判断当前票数是否大于0    
                    try {
                        Thread.sleep(100);    //使当前线程体眠 100
                    } catch (InterruptedException e) {
                        e.printStackTrace();}
                        //票数减 1
                        System.out.println(Thread.currentThread().getName()+"--票数" + num--);
                        }
                }
            }
        }
                        public static void main(String[] args){
                        //实例化类对象
                        SynchronizedTest t = new SynchronizedTest();//以该类对象分别实例化4个线程 
                        Thread tA= new Thread(t,"线程一"); 
                        Thread tB = new Thread(t,"线程二");
                        Thread tC = new Thread(t,"线程三"); 
                        Thread tD = new Thread(t,"线程四");
                        tA.start();    //分别启动线程    
                        tB.start(); 
                        tC.start(); 
                        tD.start();
                        }
                        }

2.同步方法

同步方法就是在方法前面用synchronized关键字修饰的方法,其语法如下:

synchronized void f(){}


当某个对象调用了同步方法时,该对象上的其他同步方法必须等待该同步方法执行完毕后才能被执行。必须将每个能访问共享资源的方法修饰为synchronized,否则就会出错。
修改例20.7的代码,将共享资源操作放置在一个同步方法中,代码如下:

int num = 10;
public synchronized void doit() {    //定义同步方法
if(num>0){
try{
Thread.sleep(10);
}catch(interruptedException e){
e.printStackTrace():
System.out.printin(Thread.currentThread().getName()+"-票数” +num--);
public void run(){
    while(true){
doit():    //在run()方法中调用该同步方法
 

这篇关于第二十章总结。。。的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/438706

相关文章

HarmonyOS学习(七)——UI(五)常用布局总结

自适应布局 1.1、线性布局(LinearLayout) 通过线性容器Row和Column实现线性布局。Column容器内的子组件按照垂直方向排列,Row组件中的子组件按照水平方向排列。 属性说明space通过space参数设置主轴上子组件的间距,达到各子组件在排列上的等间距效果alignItems设置子组件在交叉轴上的对齐方式,且在各类尺寸屏幕上表现一致,其中交叉轴为垂直时,取值为Vert

学习hash总结

2014/1/29/   最近刚开始学hash,名字很陌生,但是hash的思想却很熟悉,以前早就做过此类的题,但是不知道这就是hash思想而已,说白了hash就是一个映射,往往灵活利用数组的下标来实现算法,hash的作用:1、判重;2、统计次数;

git使用的说明总结

Git使用说明 下载安装(下载地址) macOS: Git - Downloading macOS Windows: Git - Downloading Windows Linux/Unix: Git (git-scm.com) 创建新仓库 本地创建新仓库:创建新文件夹,进入文件夹目录,执行指令 git init ,用以创建新的git 克隆仓库 执行指令用以创建一个本地仓库的

二分最大匹配总结

HDU 2444  黑白染色 ,二分图判定 const int maxn = 208 ;vector<int> g[maxn] ;int n ;bool vis[maxn] ;int match[maxn] ;;int color[maxn] ;int setcolor(int u , int c){color[u] = c ;for(vector<int>::iter

整数Hash散列总结

方法:    step1  :线性探测  step2 散列   当 h(k)位置已经存储有元素的时候,依次探查(h(k)+i) mod S, i=1,2,3…,直到找到空的存储单元为止。其中,S为 数组长度。 HDU 1496   a*x1^2+b*x2^2+c*x3^2+d*x4^2=0 。 x在 [-100,100] 解的个数  const int MaxN = 3000

状态dp总结

zoj 3631  N 个数中选若干数和(只能选一次)<=M 的最大值 const int Max_N = 38 ;int a[1<<16] , b[1<<16] , x[Max_N] , e[Max_N] ;void GetNum(int g[] , int n , int s[] , int &m){ int i , j , t ;m = 0 ;for(i = 0 ;

go基础知识归纳总结

无缓冲的 channel 和有缓冲的 channel 的区别? 在 Go 语言中,channel 是用来在 goroutines 之间传递数据的主要机制。它们有两种类型:无缓冲的 channel 和有缓冲的 channel。 无缓冲的 channel 行为:无缓冲的 channel 是一种同步的通信方式,发送和接收必须同时发生。如果一个 goroutine 试图通过无缓冲 channel

9.8javaweb项目总结

1.主界面用户信息显示 登录成功后,将用户信息存储在记录在 localStorage中,然后进入界面之前通过js来渲染主界面 存储用户信息 将用户信息渲染在主界面上,并且头像设置跳转,到个人资料界面 这里数据库中还没有设置相关信息 2.模糊查找 检测输入框是否有变更,有的话调用方法,进行查找 发送检测请求,然后接收的时候设置最多显示四个类似的搜索结果

java面试常见问题之Hibernate总结

1  Hibernate的检索方式 Ø  导航对象图检索(根据已经加载的对象,导航到其他对象。) Ø  OID检索(按照对象的OID来检索对象。) Ø  HQL检索(使用面向对象的HQL查询语言。) Ø  QBC检索(使用QBC(Qurey By Criteria)API来检索对象。 QBC/QBE离线/在线) Ø  本地SQL检索(使用本地数据库的SQL查询语句。) 包括Hibern

暑期学习总结

iOS学习 前言无限轮播图换头像网络请求按钮的configuration属性总结 前言 经过暑期培训,完成了五个项目的仿写,在项目中将零散的内容经过实践学习,有了不少收获,因此来总结一下比较重要的内容。 无限轮播图 这是写项目的第一个难点,在很多项目中都有使用,越写越熟练。 原理为制造两个假页,在首和尾分别制作最后一页和第一页的假页,当移动到假页时,使用取消动画的方式跳到