Java多线程(一):
https://blog.csdn.net/Veer_c/article/details/103842078
Java多线程(二):
https://blog.csdn.net/Veer_c/article/details/103842263
Java多线程(三):
https://blog.csdn.net/Veer_c/article/details/103842317
Java多线程(四):
https://blog.csdn.net/Veer_c/article/details/103842602
线程中的一些方法
1.线程加入
public final void join()
等待该线程中止,其他线程才能继续抢着执行,因为线程执行的时候,每个线程都会抢占CPU的执行权,所以我们可以利用此方法先让一个线程执行完毕后,然后再去执行其他的线程。
package com.edu_01;
public class MyThread extends Thread{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(getName()+"--"+i);
}
}
}
public class Test {
public static void main(String[] args) {
//创建三个线程
MyThread mt1 = new MyThread();
MyThread mt2 = new MyThread();
MyThread mt3 = new MyThread();
//给线程起名字
mt1.setName("刘备");
mt2.setName("曹操");
mt3.setName("孙权");
//开启三个线程
mt1.start();
//接着让mt1这个线程设置为加入线程,其他线程就没有抢占cpu执行权的权利了,只能等待该线程执行完毕之后,才能开始抢占
try {
mt1.join();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
mt2.start();
mt3.start();
}
}
2.线程礼让
public static void yield():暂停当前正在执行的线程对象,并执行其他线程。
作用:让线程间的执行更和谐一些,也就是让线程抢占CPU的概率相同一点。
package com.edu_02;
public class MyThread extends Thread{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.getName()+"---"+i);
//实现线程礼让
Thread.yield();
}
}
}
public class Test {
public static void main(String[] args) {
//创建两个线程
MyThread mt1 = new MyThread();
MyThread mt2 = new MyThread();
//给线程设置名字
mt1.setName("郭德纲");
mt2.setName("周立波");
//开启线程
mt1.start();
mt2.start();
}
}
3.线程死亡
public final void stop():直接杀死(即终止当前运行的线程,线程不会往下执行)
public void interrupt():直接杀死,在死前,还可以有遗言。(也就是说,线程还可以将该程序执行完)
package com.edu_03;
import java.text.SimpleDateFormat;
import java.util.Date;
public class MyThread extends Thread{
@Override
public void run() {
//打印一下开始执行的时间
System.out.println("开始时间:"+new SimpleDateFormat("HH:mm:ss").format(new Date()));
//休眠10秒钟
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
//e.printStackTrace();
System.out.println("我被杀死了");
}
System.out.println("结束时间:"+new SimpleDateFormat("HH:mm:ss").format(new Date()));
}
}
public class Test {
public static void main(String[] args) {
//创建线程对象
MyThread mt = new MyThread();
//开启线程对象
mt.start();
//在线程处于睡眠的过程中将他杀死
try {
Thread.sleep(3000);
//杀死刚刚开启的线程
//调用stop()方法将线程直接杀死
//mt.stop();//划了一条横线表示该方法已经过时,但是还可以使用
//interrupt():直接杀死,在死前,还可以有遗言。
mt.interrupt();//线程被杀死之后会将后面的代码执行完毕之后,再死去
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
4.线程休眠
static void sleep(long millis) 线程睡一会,让线程休眠,一定会醒来的。
线程的生命周期
1.新建:线程的对象调用Start()方法
2.就绪:线程有cpu的执行权,但是没有CPU执行资格,开始抢占CPU的执行权
3.运行:抢占到了CPU的执行权,开始执行。(如果被其他线程抢到了执行权,则会恢复到就绪状态)
4.有可能阻塞:线程对象调用sleep方法,wait方法,在线程睡醒之后,或者被唤醒之后,就会恢复到就绪状态,
5.死亡:线程调用stop方法,或者调用interrupt方法,或者在线程执行完run方法后。
再来张颜色不单调的。
下面对线程生命周期中的 7 种状态做说明:
出生状态:用户在创建线程时所处的状态,在用户使用该线程实例调用 start() 方法之前,线程都处于出生状态。
就绪状态:也称可执行状态,当用户调用 start() 方法之后,线程处于就绪状态。
运行状态:当线程得到系统资源后进入运行状态。
等待状态:当处于运行状态下的线程调用 Thread 类的 wait() 方法时,该线程就会进入等待状态。进入等待状态的线程必须调用 Thread 类的 notify() 方法才能被唤醒。notifyAll() 方法是将所有处于等待状态下的线程唤醒。
休眠状态:当线程调用 Thread 类中的 sleep() 方法时,则会进入休眠状态。
阻塞状态:如果一个线程在运行状态下发出输入/输出请求,该线程将进入阻塞状态,在其等待输入/输出结束时,线程进入就绪状态。对阻塞的线程来说,即使系统资源关闭,线程依然不能回到运行状态。
死亡状态:当线程的 run() 方法执行完毕,线程进入死亡状态。
提示:一旦线程进入可执行状态,它会在就绪状态与运行状态下辗转,同时也可能进入等待状态、休眠状态、阻塞状态或死亡状态。
使线程处于就绪状态有如下几种方法。
调用 sleep() 方法。
调用 wait() 方法。
等待输入和输出完成。
当线程处于就绪状态后,可以用如下几种方法使线程再次进入运行状态。
线程调用 notify() 方法。
线程调用 notifyAll() 方法。
线程调用 intermpt() 方法。
线程的休眠时间结束。
输入或者输出结束。
线程间通信(生产消费者问题):不同类型线程针对同一个资源的操作
1.系统不仅要卖票还要入票,每次生产一张票,就会卖出去一张票,称为单生产单消费问题。
2.不仅要卖肉夹馍还要生产肉夹馍,可以利用多个线程去生产肉夹馍,然后利用多个线程去出售,称为多生产多消费问题。
案例:以给学生设置和获取姓名和年龄为例,演示线程通信问题
线程间通讯:
资源:Student
设置数据线程:SetThread
获取数据线程:GetThread
测试类:StudentDemo
package com.edu_04;
public class Student {
String name;
int age;
}
public class SetThread implements Runnable{
private Student s;
private int x=0;
public SetThread(Student s){
this.s = s;
}
@Override
public void run() {
//给学生对象设置姓名和年龄
//Student s = new Student();
while (true) {
synchronized (s) {
if (x%2==0) {
s.name = "刘嘉玲";
s.age = 50;
}else {
s.name = "陈冠希";
s.age = 35;
}
x++;
}
}
}
}
public class GetThread implements Runnable{
private Student s;
public GetThread(Student s){
this.s = s;
}
@Override
public void run() {
//获取线程,获取学生对象的姓名和年龄
//Student s = new Student();
while (true) {
synchronized (s) {
System.out.println(s.name+"--"+s.age);
}
}
}
}
public class StudentDemo {
public static void main(String[] args) {
//创建一个学生对象
Student s = new Student();
//创建设置和获取线程,并开启线程
SetThread st = new SetThread(s);
GetThread gt = new GetThread(s);
Thread t1 = new Thread(st);
Thread t2 = new Thread(gt);
//开启线程
t1.start();
t2.start();
}
}
问题1:控制台出现的结果是:null—0
因为我们在在创建对象的时候,setThread()和getThread()的对象不是同一个,所以在输出的时候,因为setThread()还没有设置对象,所以我在传递参数的时候可以自己创建构造方法,让这个参数一致
设置和获取线程使用的学生资源不是同一个,把资源作为构造参数传递即可。
问题2:
相同的数据出现了多次,CPU的一点点时间就足够我们的程序执行很多次
数据出现了问题(数据安全问题)
a:是否是多线程环境 是
b:是否有共享数据 是
c:是否有多条语句操作共享数据 是
既然我们知道它是出现了数据安全问题,我们就应该来解决它。
如何解决呢?加锁
问题3:加了锁以后,数据还是有问题
A:多个线程都要加锁
B:多个线程加的锁必须是同一把锁
因为,线程在执行的时候,每个线程的都会有抢占的随机性,所以输出的时候没有那么和谐,而且会出现错误的数据,出现线程不安全问题,所以我们要给线程加锁,保证线程数据安全,我们可以用等待,唤醒机制保证数据的和谐
将上述代码使用等待唤醒机制改进,实现礼让效果
package com.edu_05;
public class Student {
String name;
int age;
boolean flag;//在这里可以作为对象的一个标记,如果是false说明该对象没有数据,如果是true说明该对象有数据
}
public class SetThread implements Runnable{
private Student s;
private int x = 0;
public SetThread(Student s){
this.s = s;
}
@Override
public void run() {
while (true) {
synchronized (s) {
//判断该对象此时有没有数据
if (s.flag) {
//等待
try {
s.wait();//设置线程等待,释放锁s
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if (x%2==0) {
s.name = "刘嘉玲";
s.age = 50;
}else {
s.name = "冠希";
s.age = 35;
}
x++;//x=1
//此时对象有数据了
s.flag = true;
s.notify();//如果有等待的线程就唤醒,如果没有等待的线程,则没有任何效果
}//在此时释放锁对象s
}
}
}
public class GetThread implements Runnable{
private Student s;
public GetThread(Student s){
this.s = s;
}
@Override
public void run() {
while (true) {
synchronized (s) {
//判断对象有没有数据
if (!s.flag) {
//等待设置线程给对象设置数据
try {
s.wait();//获取线程处于等待状态,释放锁对象s,在哪里跌倒在哪里爬起来
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println(s.name+"--"+s.age);//刘嘉玲--50
//冠希--35
//刘嘉玲--50
//当获取线程从学生对象中获取了数据之后,我们就默认他已经没有数据了,此时我们应该
//继续让设置线程继续给学生对象设置信息
s.flag = false;
s.notify();
}
}
}
}
public class StudentDemo {
public static void main(String[] args) {
//创建学生对象
Student s = new Student();
//创建设置线程和获取线程
SetThread st = new SetThread(s);
GetThread gt = new GetThread(s);
Thread t1 = new Thread(st);
Thread t2 = new Thread(gt);
//开启线程
t1.start();
t2.start();
}
}
将上述代码继续优化:可以将上述代码封装成方法
1.私有化Student类的成员变量
2.在类的内部提供设置和获取的同步方法
public class Student {
//块编辑(alt+shift+a):在使用块编辑的时候,一定要将输入法切换到英文输入法,不然会出问题
private String name;
private int age;
private boolean flag;//在这里可以作为对象的一个标记,如果是false说明该对象没有数据,如果是true说明该对象有数据
//提供公共的方法设置信息
public synchronized void setInfo(String name,int age){
if (this.flag) {
//等待
try {
this.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
//没有值的话,在这里给对对象设置数据
this.name = name;
this.age = age;
//更改标记,唤醒获取线程获取数据
this.flag = true;
this.notify();
}
//提供公共的方法获取信息
public synchronized void getInfo(){
if (!this.flag) {
//没有值
try {
this.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
//有数据,取数据
System.out.println(this.name+"--"+this.age);
//取完数据之后,就没有数据了
this.flag = false;
this.notify();
}
}
public class SetThread implements Runnable{
private Student s;
private int x = 0;
public SetThread(Student s){
this.s = s;
}
@Override
public void run() {
while (true) {
if (x%2==0) {
s.setInfo("刘嘉玲", 50);
}else {
s.setInfo("陈冠希", 35);
}
x++;//x=1
}
}
}
public class GetThread implements Runnable{
private Student s;
public GetThread(Student s){
this.s = s;
}
@Override
public void run() {
while (true) {
s.getInfo();
}
}
}
public class StudentDemo {
public static void main(String[] args) {
//创建学生对象
Student s = new Student();
//创建设置线程和获取线程
SetThread st = new SetThread(s);
GetThread gt = new GetThread(s);
Thread t1 = new Thread(st);
Thread t2 = new Thread(gt);
//开启线程
t1.start();
t2.start();
}
}
Java多线程(一):
https://blog.csdn.net/Veer_c/article/details/103842078
Java多线程(二):
https://blog.csdn.net/Veer_c/article/details/103842263
Java多线程(三):
https://blog.csdn.net/Veer_c/article/details/103842317
Java多线程(四):
https://blog.csdn.net/Veer_c/article/details/103842602