线程的基本语法

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. 将功能主体代码写到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.4 注意事项

直接调用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. 将需做的某个功能封装成一个线程体，该线程可以独立的获得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. 设置自己定义的线程的优先级
2. 线程的默认优先级和创建它的环境线程的当前优先级一致，主线程的默认优先级是5
3. 小结：
4. 知道调用对应的方法来获得和设置线程的优先级
5. 想办法测试高优先级的执行机会高于低优先级？

6. 6.3 守护线程

   什么守护线程

    

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

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

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

9. 特点：

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

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

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

     

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

     

    ① 相关的方法：

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

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

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

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

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

11. 小结

12. ① 知道什么是守护线程

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

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

    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为线程当中的方法，某线程实例调用该方法，其他线程会等待该线程执行完毕之后在执行

 线程礼让

线程之前相互客气一下

static void

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

1. 线程同步[解决线程安全问题]

2.1为什么需要线程同步

1. 解决问题： 线程安全问题

（例如1单例模式的懒汉模式；例如2多线程模拟多窗口售票-）

2.2 线程同步方式一：同步代码

2.2.1基本语法结构

synchronized (同步监听对象) {

可能引发线程安全问题的代码

}

上面的结构相当于把{ }中的代码捆绑成一个整体，线程只能够一个一个的进来，执行完一个，下一个才能进来

2.2.2语法特点：

1. 上面的同步监听对象可以是任意的对象；
2. 保证所有的线程共享一个同步监听对象的；也就是保证被同步监听对象是被所有线程共享的。
3. 很多时候可以写this,但是请先参照②，
4. 常用的方式：使用类的字节码对象   XXX.class

 

1. 线程通信与等待唤醒

3.1 什么是线程通信

感觉是多个线程之间会发生一些关系，会交流.......

1. 线程的生命周期

1. 简单来说就是从什么时候开始，到什么时候结束
2. 线程的声明周期分几个阶段：
   • • 线程 ;  类  女朋友

① 创建  ;  例如  Thread  t = new Thread();   女朋友

② 就绪  ;  调用了start方法  t.start()  ---> 告诉CPU我准备好了  女朋友准备好了

③ 运行  ;  获得CPU的资源，开始执行线程体中的代码

④ 死亡  ;  有多种情况导致死亡，

1. 例如线程体执行完毕（自然老死）；漏气.....
2. 非自然死亡（异常没有处理好）;
3. 对象失去引用  被人偷了
4. 对象被垃圾回收机制销毁  丢弃

3、注意点：

① 休眠等操作可能导致正在运行的线程阻塞]，阻塞完了（sleep完了）进入的是就绪状态

相互一一直等待,出现死锁!

② 一个线程死了就死了，不能够死而复生

 

1. 定时器

5.1什么是定时器？

java.util.TimerTask由 Timer 安排为一次执行或重复执行的任务。

5.2定时器重复执行任务的认识

1. 定时炸弹

       

1. 1. 定时炸弹：一个炸弹+一个定时器组成的
   2. 原理：当定时器到指定的时间了就引爆炸弹（到了指定的时间执行指定的任务）
2. 闹钟
   1. 到了指定的时间就（响铃+震动）
   2. 重复每天固定的时间都要响
3. 定时邮件发送

5.2 Java中是的实现方式  java.util.Timer

1. 这个类就是一个定时器的类而已，
2. 就想做一个定时炸弹，怎么下手呢？

需要有一个炸弹

需要有一个定时器 Timer

在Timer上需要的操作：设置时间（调用其中的方法）

1. Java中已经提供了一个类，供我们使用java.util.timer
2. Timer类：（定时器对象）具有设计时间，时间到了在执行任务的功能;
3. Timer类常用方法:

void	schedule(TimerTask task, long delay) 安排在指定延迟后执行指定的任务
示例代码：

转载于:https://my.oschina.net/u/4083692/blog/3027685