Day23
本单元目标
一.线程的相关概念
二.线程的创建和启动★
三.线程的停止
四.线程的常用方法
五.线程的生命周期★
六.线程的同步
七.线程的通信
八.线程的创建方式三
九.线程的创建方式四(线程池)
一.线程的相关概念
程序：是完成特定任务、用某种语言编写的一组指令的集合
进程：是程序的一次执行过程，或是正在运行的一个程序
线程：进程可进一步细化为线程，线程是进程中的一个细小的单元
单线程：一个程序，在“同一时刻”只能执行一个线程
多线程：一个程序，在“同一时刻”可以同时执行多个线程
双核
多核
高并发
高频率
二、线程的创建和启动
1、之前的所有代码都是单线程
2、线程的创建方式（两种）一共是四种
2.1 a 新建一个类
b 继承一个类Thread
c 重写run方法（实际运行的代码）
启动线程的方式：
a。 创建一个线程对象
Thread1 t1=new Thread1（）；
b。调用当前线程的start方法
t1.start();//启动线程的正确方式（实际运行的依然是run方法）
2.2
a 新建一个类
b实现一个接口Runable
c实现接口中的抽象方法 run方法
启动线程的方式
a 创建线程对象
b通过Thread类进行包装
c调用Start方法进行启动
t22.start（）；//实际运行的依然是t2的run 方法
3、 练习
1 创建两个子线程，让其中一个输出1-100之间的偶数，另一个输出1-100之间的奇数。
package Demo;
//创建两个子线程，让其中一个输出1-100的偶数，另一个输出1-100之间的奇数
public class Demo3 {
public static void main(String[] args) {
Thread1 t1=new Thread1();
t1.start();
Thread2 t2=new Thread2();
Thread t22=new Thread(t2);
t22.start();
}
}
class Thread1 extends Thread{
@Override
public void run() {
// TODO Auto-generated method stub
for (int i = 0; i < 101; i++) {
if (i%2==0) {
System.out.println("偶数"+i);
}
}
super.run();
}
}
class Thread2 implements Runnable{
@Override
public void run() {
// TODO Auto-generated method stub
for (int i = 0; i < 101; i++) {
if (i%2!=0) {
System.out.println("奇数："+i);
}
}
}
}
三、线程常见方法
1. 如何停止一个线程
a stop(); 停止一个线程 过时了 不建议使用
b 可以采用逻辑的方式
四.线程的常用方法
currentThread();获得当前线程的对象 静态方法
Thread[Thread-0,5,main] [当前线程的名字,当前线程的优先级,当前线程由哪个线程创建的]
getName();获得线程的名字
setName(String name);设置当前线程的名字
getPriority();获得当前线程的优先级 线程的优先级默认和创建他的线程优先级一致
setPriority(2);设置当前线程的优先级 范围：1-10
sleep(long time);睡眠 设置时间 单位：毫秒 需要抛出一个异常 InterruptedException e
interrupt();中断（不能中断线程） (只是改变了当前线程中一个值的状态)
在中断睡眠或者等待的线程时会抛出一个异常
线程分类
* 守护线程 (负责守护) 当用户线程执行完毕，自己线程无论是否执行完毕都自动结束！
如何设置守护线程 t1.setDaemon(true);//设置为守护线程 需要在启动之前设置
记住守护线程的特点：
java一个最经典的守护线程是 ：垃圾回收机制的线程
用户线程 (功能)
2. 练习
编写程序：在main方法中创建一个线程。线程每隔一定时间（200ms以内的随机时间）
2.定义一个接口用来实现两个对象的比较。
interface CompareObject{
public int compareTo(Object o);
//若返回值是 0 , 代表相等; 若为正数，代表当前对象大；负数代表当前对象小
}
定义一个Circle类。
定义一个ComparableCircle类，继承Circle类并且实现CompareObject接口。
在ComparableCircle类中给出接口中方法compareTo的实现体，用来比较两个圆的面积大小。
定义一个测试类InterfaceTest，创建两个ComparableCircle对象，
调用compareTo方法比较两个类的半径大小。 产生一个0-100之间的随机整数，打印后将该整数放到集合中；
共产生100个整数，全部产生后，睡眠5秒，然后将集合内容打印输出；
package Demo;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/*在main方法中创建一个线程。线程每隔一定时间（200ms以内的随机时间）
* 产生一个0-100之间的随机整数，打印后将该整数放到集合中；
共产生100个整数，全部产生后，睡眠5秒，然后将集合内容打印输出；*/
public class Demo4 {
public static void main(String[] args) {
Thread3 t1=new Thread3();
t1.start();
}
}
class Thread3 extends Thread{
List<Integer> list =new ArrayList<Integer>();
@Override
public void run() {
super.run();
// TODO Auto-generated method stub
for (int i = 0; i <100; i++) {
try {
Thread.sleep((long) (Math.random()*200+1));
} catch (Exception e) {
// TODO: handle exception
}
int a = (int)(Math.random()*101);
System.out.println(a);
list.add(a);
}
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
for (Integer integer : list) {
System.out.print(integer);
}
五.线程的同步
1、线程的同步
多个窗口买票
1. 互斥锁
a. 为一段代码块上锁
语法：
synchronized(锁对象){//锁对象是任意对象(this或String对象)
需要锁住的代码;关键代码
}
b. 为一段代码块上锁
语法：public synchronized void method（）{
//如何让循环结束
}
C.
1.创建一个对象
ReentrantLock lock=new ReentrantLock（）；
2.在需要被锁住的上一行执行lock方法
lock.lock();
3.在需要被锁住的最后一行下一行执行unlock方法(必须要执行：finally中)
Lock.unlock(); （必须被执行：finally里中）
4. 案例
try {
lock.lock();
if(num<=0){
System.out.println("卖完了");
break;
}
try {
Thread.sleep(400);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"卖出了一张票：剩余："+--num);
} finally {
lock.unlock();//一定要保证能运行 finally中
}
2、死锁的问题
1、产生原因：
就是锁与锁之间的相互等待
一个线程一直占用这个资源，另一个线程一直在等待他结束
此类用于演示死锁 (避免)
1. 产生的原因：
就是锁与锁之间相互等待
2. 案例见下面代码
public class Demo2 {
public static void main(String[] args) {
Thread1 t1=new Thread1();//新生线程
t1.start();//就绪(可运行)线程
Thread2 t2=new Thread2();
t2.start();
}
}
class Thread1 extends Thread{
@Override
public void run() {
System.out.println("这是Thread1线程");
synchronized ("java") {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Thread1刚刚睡醒");
synchronized ("html5") {
System.out.println("Thread1内部锁的代码");
}
}
}
}
class Thread2 extends Thread{
@Override
public void run() {
System.out.println("这是Thread2线程");
synchronized ("html5") {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("Thread2刚刚睡醒");
synchronized ("java") {
System.out.println("Thread2内部锁的代码");
}
}
}
}
解决懒汉模式
package com.atguigu.demon;
/**
* 此类用于演示解决懒汉模式的线程安全问题
* 1. 代码见下面
*/
public class Demo3 {
}
class Lazy{
private Lazy(){}
private static Lazy lazy;
public static Lazy getLazy(){
if(lazy==null){
synchronized ("aaa") {
if(lazy==null){
lazy=new Lazy();
}
}
}
return lazy;
}
}
六.线程的生命周期★
1、新生线程，（线程对象刚刚诞生）刚new出来
可运行（就绪）线程（调用Start方法）
运行线程 （等待cpu分配执行权）
阻塞线程
睡眠sleep
互斥锁
io阻塞
暂停join
等待wait
死亡线程
以上需要背下来
2、线程的让步和线程的插队
a.线程的让步
Thread.yield()
礼让只是比自己优先级高或者同级别的
如果不满足这个条件该方法失效
抢到之后只让一次，下次抢到直接执行
b.线程的插队
this.join();
调用方法时，调用线程将被阻塞，直到join（）方法加入的join方法执行完成。
让给谁，谁执行完，我才执行
七.线程的通信
1、需求
启动两个线程：一个线程做普通打印操作（0.5秒打印一次） 另一个线程去监控键盘，
如果有输入则暂停另一个线程的打印，如果在次检测到键盘有输入，继续运行上一个线程
package com.atguigu.demon;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
/**
* 此类用于演示线程的通信
*/
public class Demo5 {
public static void main(String[] args) {
Thread51 t1=new Thread51();
t1.start();
Thread52 t2=new Thread52();
t2.start();
Thread53 t3=new Thread53();
t3.start();
}
}
class Thread51 extends Thread{
public static boolean flag=false;
@Override
public void run() {
while(true){
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
if(flag){
//让当前线程暂停(等待)
synchronized ("java") {
try {
"java".wait();//Object
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
System.out.println(Math.random());
}
}
}
class Thread53 extends Thread{
public static boolean flag=false;
@Override
public void run() {
while(true){
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
if(flag){
//让当前线程暂停(等待)
synchronized ("java") {
try {
"java".wait();//Object
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
System.out.println("Thread53-----------"+Math.random());
}
}
}
class Thread52 extends Thread{
@Override
public void run() {
BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
try {
in.readLine();
//需要改变flag的值
Thread51.flag=true;
Thread53.flag=true;
in.readLine();
Thread51.flag=false;
Thread53.flag=false;
synchronized ("java") {
// "java".notify();//唤醒在"java"这个对象下等待的线程
"java".notifyAll();//唤醒所有在"java"这个对象下等待的线程
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
2. 方法
wait(); 等待 (出现在哪个线程中哪个线程等待)
"java".notify();//唤醒在"java"这个对象下等待的线程 每次只能唤醒一个
"java".notifyAll();//唤醒所有在"java"这个对象下等待的线程
特点：
必须用在synchronized方法或synchronized代码块中，
这三个方法全部来自于Object类
八.线程的创建方式三
1、第三种创建方式
a 新建一个接口
b 实现一个接口Callable<方法的返回值>
c 实现抽象方法Call（）
启动方式 ：
创建对象：FutureTask<String> ft=new FutureTask<>(new Thread61());
使用Thread类进行包装：Thread t=new Thread(ft);
调用start方法启动：t.start();
如何拿到返回值
String str=ft.get();//返回类型默认是泛型类型
特点：
主要是和第二种创建方式的对比
a. 支持泛型
b. 不需要手动处理异常
c. 有返回值
FutureTask<String> ft=new FutureTask<>(new Thread61());
Thread t=new Thread(ft);
t.start();//运行的是call方法
//返回值如何拿
try {
String str=ft.get();
System.out.println("-----------"+str);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ExecutionException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
class Thread61 implements Callable<String>{
@Override
public String call() throws Exception {
String str="java";
for (int i = 0; i < 10; i++) {
str+=i;
System.out.println(str);
}
return str;
}
}
九.线程的创建方式四(线程池)
2. 第四种创建方式 (线程池) 数据库连接池
a. 创建了一个线程池容量为5
ExecutorService es=Executors.newFixedThreadPool(5);
b. submit(Runnable/Callable<>); 添加子线程 直接就启动
c. 关闭资源
es.shutdown();
public class Demo6 {
public static void main(String[] args) {
//第四种创建方式
//1. 创建了一个线程池容量为5
ExecutorService es=Executors.newFixedThreadPool(5);
//2. 添加子线程
es.submit(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("----------"+i);
}
}
});
es.submit(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(">>>>>>>>>>"+i);
}
}
});
//3. 关闭
es.shutdown();
}
}
684
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
