java线程的基本语法

线程的基本语法

1.课程介绍

• ① 什么是线程
• ② 创建启动线程的两种方式
• ③ Thread中的常用方法

1. 线程的概念

2.1常识引入

1. 我们知道CPU是计算机中央处理器，用来处理任务的，那么他是如何处理任务的，在实际使用过程中，听说过多线程软件，比如迅雷，快播，等下载速度比较快....。

 

2.2什么是线程

1. 任务管理器可以有多个进程，每个进程运行的都是可执行程序，一个可执行程序就是一个软件，可执行程序的本质就是在计算机当中运行的一块代码

进程：可以看成是在计算机当中运行的一块代码

线程：可以看成是在计算机当中运行的一小块代码

2.3线程与进程的关系

1. 一个进程中可以有多个线程，至少得有一个线程；
2. 上面说一个进程可以狭隘的看成是一大段代码，那其实线程也是一段代码
3. 线程是进程中的最小单位；
4. 也可以把线程看成是一个轻量级的进程

注意常识 : 计算机安装一个软件，软件是由代码构成，当启动一个软件之后，代码被放入内存中，为什么会放入到内存中，因为内存的读写速度比较快，这时候CPU就开始处理内存当中的任务，也就是当前软件程序[ 代码 ]运行起来了。

2.4 CPU如何处理任务?

1. 在单位时间时间片上只能执行一个线程
2. CPU看到内存中有很多的线程，CPU在单位时间片（时间片：很微小的时间单位）上高速切换线程执行

2.5多线程下载软件为什么快

1. 问题:很多使用多线程技术开发的软件，下载速度比较快，例如，迅雷.....某些软件，QQ影音，快播..迅雷影音等等...为什么下载速度会比较快

1. 假设上面软件都是运行在同一台电脑上面，两款软件运行，肯定是由一个CPU在处理该任务
2. CPU处理任务最小单位是线程，CPU是通过资源分配的方式，在多个线程之间，以时间片（时间片：很微小的时间单位）为单位，高速切换内存中要执行的线程任务。
3. 在同一个时间片上，只能处理一个线程
4. 在CPU的眼中，只看到内存中有很多线程，大家都是平等的，获取到CPU处理的机会是均等的，CPU会平均分配资源给每一个线程
5. 假设每个线程执行一分钟，快播软件占用CPU时间为三分钟，迅雷占用CPU处理任务的时间为1分钟，自然快播处理的任务会更多，下载的内容更多

 

2.6线程的作用

1. 线程的作用：看下面两种理解方式：

①可以将代码中（软件）的某些独立的功能包装起来，单独作为任务交给CPU处理！

②将需做的某个功能封装成一个线程体，该线程可以独立的获得CPU分配的资源

从而实现多功能同时运行。

1. 自定义第一个线程

3.1 场景描述

1. 开发一个游戏（LOL）,实现的功能一边玩游戏，一边播放背景音乐

3.2 实现流程分析

1. 游戏的本质也是软件：该软件包含两项功能

①玩游戏，暂时使用一个打印语句来代替该功能的演示

②播放背景音乐，暂时也使用一个打印语句来代替该功能

3.3 代码实现

 

1. 将功能代码写在哪里
   1. 1. 1. 将功能主体代码写到Thread类中run方法里面？
         2. 如果Thread类当中，写了游戏功能，那么播放音乐怎么办？？？
         3. 所以不能写在Thread类当中
2. 我们需要自己定义类继承Thread类，不但具有里面的东西，还具有Thread类的特性，自定义类也是一个线程类，然后覆写run方法，然后把我们的代码写在我们覆写的run方法里面，然后启动
3. 根据上面的场景我们需要创建哪些类？

① 玩游戏的线程类

② 放音乐的线程类

③ 测试类：创建①  ②的对象，然后调用start方法启动

 

1. 代码清单：

public class PlayGameThread extends Thread{

public void run() {

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

System.out.println("double kill...");

}

}

}

 

public class MusicThread extends Thread{

public void run() {

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

System.out.println("摩擦。。。摩擦...");

}

}

}

 

public class Test {

public static void main(String[] args) {

PlayGameThread pgt = new PlayGameThread();

MusicThread mt = new MusicThread();

 

pgt.start();

mt.start();

}

}

3.4 小结：创建启动线程的方式一（继承Thread类）

1. 先明确我们需要把什么事情封装成一个线程对象（现有相应的代码）
2. 自定义一个类 extends  Thread
3. 覆写run方法，在这里写1步中的代码
4. 创建一个自定义类的对象 t
5. 启动线程  t.start();
6. 注意执行过程：本质是代码执行到一个位置之后，如果切换到另一个线程，在切换回来，那么会从刚才切换走的代码位置继续执行：产生线程安全问题的原因，就在此...

 

3.5 注意事项

直接调用run方法和start的区别？

1. 可以直接调用run方法，但是没有启动一个独立的线程；
2. 只有调用start 才回启动一个独立的线程；

自己启动的线程和主线程有关系吗？

1. 直接写一个最简单的hello word 程序，就有一个主线程
2. 一个线程一旦启动就是独立的了，和创建启动它的环境没有直接的包含关系

代码清单：

public class Test2 {

/** 测试主线程执行完毕我们自定义的线程还是会继续执行（前提就是主线程完了，自定义的线程还没有执行完）*/

public static void main(String[] args) {

System.out.println("hello...");

new ThreadTest().start();

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

System.out.println("main"+i);

}

}

}

class ThreadTest extends Thread{

public void run() {

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

System.out.println("自定义线程"+i);

}

}

}

 

1. 案例分析：多线程售票示例

4.1需求分析：多线程模拟多窗口售票

思考：上面示例应该这么下手？

1. 票，用什么来存放票：票池

可以使用一个变量来表示票池，当卖出一个张票，该变量就自减一次

int num = 50;

1. 本质就是要创建启动线程（流程）

明确需要把什么事情封装成独立的线程对象

卖（一张）票的操作

怎么操作

判断是否有票，如果有票就卖一张

票总数减一

1. 怎么实现：

自定义一个类 extends Thread类

实现功能自定义类覆写Thread类当中的run方法，实现伪代码功能

创建线程对象调用start方法启动线程

问题：-----------------------》

1. 共享问题，用来存放票量的，变量应该如何被多个窗口共享
2. 应该自定义几个类？1

之前游戏有不同功能，写了不同类，卖票都是一个功能，所以定义一个类就行了

1. 应该创建几个对象？3

三个窗口，可以创建三个对象来表示三个窗口

4.2代码实现

问题1：为什么只卖了三张票

run方法当中为线程主体：该程序只会执行一次，所以线程主体程序结束了，线程任务也就完成了。

问题2：为什么卖的票号都是50

Ticket类创建了三个对象，每个对象都有一个变量sum,所以每个线程对象都是使用的实例变 量

如何解决上面的两个问题？

①run方法中主体类容，应该循环销售票池剩余票量，直到票量为0销售才结束，也就是线程主体程序才结束，所以应该采用循环来实现

②如何实现票池被多个对象共享，使用static关键字

如果不加static关键字会卖多少张？150,三个对象卖五十张，所以一共买了150张

 

代码版本2：

 

 

最终代码：

 

 

52张结果分析？

代码版本2：  num使用static修饰

结果： 52张左右

原因： 多线程操作同一个数据导致的线程安全问题-----》单例模式中有一种（懒汉模式）也存在线程安全问题

简单分析：CPU执行线程任务：本质是代码执行到一个位置之后，如果切换到另一个线程，在切换回来，那么会从刚才切换走的代码位置继续执行

假设票池数据为50

线程对象tk1执行到代码位置③，并未执行sum--位置4，此时CPU切换线程执行，票池数据仍为50

tk1售出票号为50

线程对象tk2执行到代码位置②，并未执行sum--位置4，此时CPU切换线程执行，票池数据仍为50

tk2售出票号为50

此时：tk2执行到代码位置③；并未执行sum--位置4，切换线程

线程对象tk3执行到代码位置②，并未执行sum--位置4，此时CPU切换线程执行，票池数据仍为50

线程安全问题怎么解决：？？？

这个问题，今后会学到线程同步，该内容只允许一个线程访问，当对象访问结束之后，别的线程才能进行访问。以后讲......

 

友好提示：注意分析清楚此处问题，对于明天学习线程同步由极大帮助，否者晕车！！！！！！！

1. 实现创建启动线程方式二

5.1 线程的创建启动方式二

 

1. 将需做的某个功能封装成一个线程体，该线程可以独立的获得CPU分配的资源

从而实现多功能同时运行。

Thread线程类本质是实现Runnable接口

 

1. 通过查看API得知，Thread当中的run方法不是来自于自身，而是通过实现Runable接口里面的run方法，从而实现某个类的实例，可以通过线程的方式实现功能，类必须定义一个名为run的无参数方法
2. 本质Thread也是通过实现接口来实现线程功能的
3. 如果自定义一个类，完全可以是通过实现该接口从而，通过线程实现功能

 

自定义类通过实现Runable的方式来实现线程，如何启动

 

1. 通过实现Runable实现线程的，自定义类，的对象A。放在一个空壳的Thread线程对象当中
2. 然后通过该对象来调用start方法启动线程A

代码清单：

 

public class TicketThread implements Runnable{

private int num = 50;

 

public void run() {

// 最终的代码

while(num>0){

System.out.println("您的票号是："+num);

num--;

}

}

}

public class Test {

public static void main(String[] args) {

/*

 * 只需要创建一个TicketThread的对象   tt

 * 以tt为参数来创建3个Thread对象

 */

TicketThread tt = new TicketThread();

 

Thread t1 = new Thread(tt);

Thread t2 = new Thread(tt);

Thread t3 = new Thread(tt);

 

t1.start();

t2.start();

t3.start();

}

}

 

问题：

为什么上面没有static，也只销售50张票左右，而没有销售150张，本质其实只创建了一个对象，在被三个线程对象共享

5.2  小结：实现方式启动线程的流程

1. 明确线程主体（自己需要实现的代码）;
2. 自定义一个类实现Runnable接口
3. 覆写run方法  ： 写第一步中的代码
4. 创建一个自定义类的对象  t
5. 以t为参数来构造一个Thread对象  tt;

Thread  tt  =  new  Thread(tt);

1. tt.start();//启动线程对象tt,对线程对象t 的主体代码进行访问

5.3 继承Thread 和实现Runnable的区别

1. 继承有局限，Java中类只能够单继承
2. 实现的方式，我们的类在业务上可以继承它本应该有的类，同时可以实现接口变成一个线程类
3. 关于数据共享的问题：就看所谓被共享的数据所在的类的对象被创建了几个

6. Thread类

6.1 线程休眠sleep

 

线程类Thread当中有一个static void sleep(long millis)方法，在指定的毫秒数内让当 前正在执行的线程休眠

注意 : 当前正在执行的线程就是主线程

线程休眠应用

 

1. 可以做倒计时

代码清单：

Frame f = new Frame();

Label label = new Label("10");

label.setBackground(Color.RED);

// 字体对象

Font font = new Font("宋体",Font.BOLD,666);

label.setFont(font);

label.setAlignment(Label.CENTER);

f.add(label);

 

f.setSize(780, 780);

f.setLocationRelativeTo(null);

f.setVisible(true);

 

for (int i = 10; i >= 0; i--) {

label.setText(i+"");

Thread.sleep(1000);

}

1. 可以用来模拟网络延迟

6.2 线程的优先级

1.线程优先级概念：

1. 每个线程[线程对象]都有一个优先级，高优先级线程的执行优先于低优先级线程（简单说：如果一个线程的优先级越高，获得CPU资源的机会更大，不等于高优先级的就最先执行）

2.如何设置优先级呢？ 调用方法

 

1. int getPriority() 返回线程的优先级
2. void setPriority(int newPriority) 更改线程的优先级

 

3.希望验证一下上面的理论

 

1. 先通过主线程来测试获得和设置优先级

public static void main(String[] args) {

//获取主线程

Thread m = Thread.currentThread();

System.out.println(m.getPriority());//输出主线程优先级

m.setPriority(Thread.MAX_PRIORITY);//设置主线程优先级

System.out.println(m.getPriority());//输出主线程设置优先级之后的优先级

}

1. 设置自己定义的线程的优先级

 

1. 线程的默认优先级和创建它的环境线程的当前优先级一致，主线程的默认优先级是5

1. 小结：

1. 知道调用对应的方法来获得和设置线程的优先级
2. 想办法测试高优先级的执行机会高于低优先级？

6.3 守护线程

什么守护线程

 

1. 守护线程（精灵线程/后台线程）

①每个线程都可以或不可以标记为一个守护程序

②后台线程仅仅就是对线程的一个分类或者标记

1. 特点：

① 一般来说后台线程是为前台线程服务的（例如gc线程）；

② 如果所有的前台线程都死了，那么后台线程也会自动的死亡；但是前台线程死了，后台线程不一定立即死亡（可能还需要收尸...）

③ 一个线程的默认状态和创建它的环境线程状态一致

 

测试把一个线程标记为守护线程

 

① 相关的方法：

boolean isDaemon()  测试该线程是否为守护线程

void setDaemon(boolean on) 将该线程标记为守护线程或用户线程

如果上面从参数为true 表示是后台线程

② 先以主线程来进行测试：1获得  2 尝试修改

③ 自定义的线程： 1 获得 2 尝试修改

1. 小结

① 知道什么是守护线程

② 知道如何调用方法修改它的状态

③ 主线程不能够修改状态---》活动状态的线程是不能被修改的

public static void main(String[] args) {

Thread t = Thread.currentThread();

System.out.println(t.isDaemon());

// t.setDaemon(true);//活动状态的线程不能够修改后台线程

 

Thread  tt = new Thread();

System.out.println(tt.isDaemon());

//tt.start();//活动的线程不能改变状态Exception in thread "main" java.lang.IllegalThreadStateException

tt.setDaemon(true);

System.out.println(tt.isDaemon());//自定义线程未启动可设置后台线程

}

6.4 等待线程终止join()

什么是等待线程终止join

 

join为线程当中的方法，某线程实例调用该方法，其他线程会等待该线程执行完毕之后在执行

6.5 线程礼让

线程之前相互客气一下

static void

yield() 暂停当前正在执行的线程对象，并执行其他线程。

 

7.课程总结

7.1 重点

1. 线程概念的理解
2. 线程的应用场景理解
3. 创建启动线程的两种方式必须会

7.2 难点

1、介绍Thread类中的一些方法的时候我们做的验证示例可能逻辑有点多，其实我们只需要掌握方法的调用就好，内部的实现原理了解即可，这样就比较简单了

 

转载于:https://my.oschina.net/u/4083694/blog/3027068