目录
线程调度概述(线程调度了解即可)
- 1.1、常见的线程调度模型有哪些?
- 抢占式调度模型:
- 哪个线程的优先级比较高,抢到的CPU时间片的概率就高一些/多一些。
- java采用的就是抢占式调度模型。
- 均分式调度模型:
- 平均分配CPU时间片。每个线程占有的CPU时间片时间长度一样。
- 平均分配,一切平等。
- 有一些编程语言,线程调度模型采用的是这种方式。
- 抢占式调度模型:
- 1.2、java中提供了哪些方法是和线程调度有关系的呢?
- 实例方法:
- void setPriority(int newPriority) 设置线程优先级
- int getPriority() 获取线程优先级
- 最低优先级 1
- 默认优先级 5
- 最高优先级 10
- 优先级比较高的获取CPU时间片可能会多一些。(大概率是的,但也不完全是。)
- 静态方法:
- static void yield() 让位方法
- 暂停当前正在执行的线程对象,并执行其他线程
- yield()方法不是阻塞方法,让当前线程让位,让给其他线程使用。
- yiled()方法的执行会让当前线程从“运行状态”回到“就绪状态”。
- 注意,在回到就绪状态之后,有可能还会再次抢到。
- 实例方法:
-
void join()
-
合并线程
-
class MyThread1 extends Thread{
public void doSome(){
MyThread2 t = new MyThread2();
t.join(); // 当前线程进入阻塞,t线程执行,直到t线程结束。当前线程才可以继续执行。
}class MyThread2 extends Thread{
}
-
- 实例方法:
线程优先级
package com.bjpowernode.javase.thread;
public class ThreadTest11 {
public static void main(String[] args) {
// 设置主线程的优先级为1
Thread.currentThread().setPriority(1);
/*System.out.println("最高优先级" + Thread.MAX_PRIORITY);
System.out.println("最低优先级" + Thread.MIN_PRIORITY);
System.out.println("默认优先级" + Thread.NORM_PRIORITY);*/
// 获取当前线程对象,获取当前线程的优先级
Thread currentThread = Thread.currentThread();
// main线程的默认优先级是:5
System.out.println(currentThread.getName() + "线程的默认优先级是:" + currentThread.getPriority());
Thread t = new Thread(new MyRunnable5());
// 设置t线程的优先级为10
t.setPriority(10);
t.setName("t");
t.start();
// 优先级较高的,只是抢到的时间片相对多一些。
// 大概率方向会偏向优先级高的
for(int i = 0; i < 1000; i ++){
System.out.println(Thread.currentThread().getName() + "-->" + i);
}
}
}
class MyRunnable5 implements Runnable{
@Override
public void run() {
// 获取线程优先级
System.out.println(Thread.currentThread().getName() + "线程的默认优先级是:" + Thread.currentThread().getPriority());
for(int i = 0; i < 1000; i ++){
System.out.println(Thread.currentThread().getName() + "-->" + i);
}
}
}
线程让位
package com.bjpowernode.javase.thread;
/*
让位,当前线程暂停,回到就绪状态,让给其他线程。
静态方法:Thread.yield();
*/
public class ThreadTest12 {
public static void main(String[] args) {
Thread t = new Thread(new MyRunnable6());
t.setName("t");
t.start();
for(int i = 1; i <= 1000; i ++){
System.out.println(Thread.currentThread().getName() + "---->" + i);
}
}
}
class MyRunnable6 implements Runnable{
@Override
public void run() {
for(int i = 1; i <= 1000; i ++){
// 每100个让位一次
if(i % 100 == 0){
Thread.yield(); // 当前线程暂停一下,让给主线程。
}
System.out.println(Thread.currentThread().getName() + "---->" + i);
}
}
}
线程合并
package com.bjpowernode.javase.thread;
/*
线程合并
*/
public class ThreadTest13 {
public static void main(String[] args) {
System.out.println("main begin");
Thread t = new Thread(new MyRunnable7());
t.setName("t");
t.start();
// 合并线程
try {
t.join(); // t合并到当前线程中,当前线程受堵塞,t线程执行直到结束。
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("main end");
}
}
class MyRunnable7 implements Runnable{
@Override
public void run() {
for(int i = 0; i < 100; i ++){
System.out.println(Thread.currentThread().getName() + "-->" + i);
}
}
}
多线程并发环境下,数据的安全问题
- 2.1、为什么这是重点
- 以后的开发中,我们的项目都是运行在服务器当中,而服务器已经将线程的定义,线程对象的创建,线程的启动等,都已经实现完了。这些代码我们都不需要编写。
- 最重要的是:你要知道,你编写的程序需要放到一个多线程的环境下运行,你更需要关注的是这些数据在多线程并发的环境下是否是安全的。(重点:*****)
- 2.2、什么时候数据在多线程并发的环境下会存在安全问题呢?
- 三个条件:
- 条件1:多线程并发
- 条件2:有共享数据
- 条件3:共享数据有修改的行为
- 满足以上三个条件之后,就会存在线程安全问题。
- 三个条件:
- 2.3、怎么解决线程安全问题呢?
- 当多线程并发的环境下,有共享数据,并且这个数据还会被修改,此时就存在线程安全问题,怎么解决这个问题?
- 线程排队执行。(不能并发)
- 用排队执行解决线程安全问题。
- 这种机制被称为:线程同步机制。
- 专业术语叫做:线程同步,实际上就是线程不能并发了,线程必须排队执行。
- 怎么解决线程安全问题呀?
- 使用“线程同步机制”。
- 线程同步就是线程排队了,线程排队了就会牺牲一部分效率,没办法,数据安全第一位,只有数据安全了,我们才可以谈效率。数据不安全,没有效率的事儿。
- 当多线程并发的环境下,有共享数据,并且这个数据还会被修改,此时就存在线程安全问题,怎么解决这个问题?
- 2.4、说到线程同步这块,涉及到两个专业术语:
- 异步编程模型:
- 线程t1和线程t2,各自执行各自的,t1不管t2,t2不管t1,谁也不需要等谁,这种编程模型叫做:异步编程模型。
- 其实就是:多线程并发(效率较高)。
- 异步就是并发。
- 同步编程模型:
- 线程t1和线程t2,在线程t1执行的时候,必须等待t2线程执行结束,或者说在t2线程执行的时候,必须等待t1线程执行结束,两个线程之间发生了等待关系,这就是同步编程模型。效率较低。线程排队执行。
- 同步就是排队。
- 异步编程模型:
模拟两个线程对同一个账户取款
package com.bjpowernode.javase.threadsafe;
public class Account {
// 账号
private String actno;
// 余额
private double balance;
public Account() {
}
public Account(String actno, double balance) {
this.actno = actno;
this.balance = balance;
}
public String getActno() {
return actno;
}
public void setActno(String actno) {
this.actno = actno;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
// 取款的方法
public void withdraw(double money){
// t1和t2并发这个方法。。。。(t1和t2是两个栈。两个栈操作堆中同一个对象。)
// 取款之前的余额
double before = this.getBalance();
// 取款之后的余额
double after = before - money;
// 在这里模拟下网络延迟,100%会出现问题
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 更新余额
// 思考:t1执行到这里了,但还没有来得及执行这行代码,t2线程进来withdraw方法了。此时一定出问题。
this.setBalance(after);
}
}
package com.bjpowernode.javase.threadsafe;
/**
* 银行账户
* 不使用线程同步机制,多线程对同一个账户进行取款,出现线程安全问题。
*/
public class AccountThread extends Thread{
// 两个线程必须共享同一个账户对象
private Account act;
// 通过构造方法传递过来账户对象
public AccountThread(Account act){
this.act = act;
}
public void run(){
// run方法的执行表示取款操作。
// 假设取款5000
double money = 5000;
// 取款
act.withdraw(money);
System.out.println(Thread.currentThread().getName() + "对" + act.getActno() + "取款" + money + "成功,余额" + act.getBalance());
}
}
package com.bjpowernode.javase.threadsafe;
public class Test {
public static void main(String[] args) {
// 创建账户对象(只创建一个)
Account act = new Account("act-01", 10000);
// 创建两个线程
Thread t1 = new AccountThread(act);
Thread t2 = new AccountThread(act);
// 设置name
t1.setName("t1");
t2.setName("t2");
// 启动线程取款
t1.start();
t2.start();
}
}
同步代码块synchronized
package com.bjpowernode.javase.threadsafe2;
public class Account {
// 账号
private String actno;
// 余额
private double balance;
public Account() {
}
public Account(String actno, double balance) {
this.actno = actno;
this.balance = balance;
}
public String getActno() {
return actno;
}
public void setActno(String actno) {
this.actno = actno;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
// 取款的方法
public void withdraw(double money){
// 以下这几行代码必须是线程排队的,不能并发。
// 一个线程把这里的代码全部执行结束之后,另一个线程才能进来。
/*
线程同步机制的语法是:
synchronized(){
// 线程同步代码块。
}
synchronized后面小括号中传的这个“数据”是相当关键的。
这个数据必须是多线程共享的数据。才能达到多线程排队的效果。
()中写什么?
那要看你想让哪些线程同步。
假设t1、t2、t3、t4、t5,有5个线程,
你只希望t1 t2 t3排队,t4 t5不需要排队。怎么办?
你一定要()中写一个t1 t2 t3共享的对象,而这个
对象对于t4 t5来说不是共享的。
这里的共享对象是:账户对象。
账户对象是共享的,那么this就是共享的。
不一定是this,这里只要是多线程共享的那个对象就行。
在java语言中,任何一个对象都有“一把锁”,其实这把锁就是标记。(只是把它叫做锁。)
100个对象,100把锁。1个对象1把锁。
以下代码的执行原理?
1、假设t1和t2线程并发,开始执行以下代码的时候,肯定有一个先一个后。
2、假设t1先执行了,遇到了synchronized,这个时候自动找“后面共享对象”的对象锁,
找到之后,并占有这把锁,然后执行同步代码块中的程序,在程序执行过程中一直都是占
有这把锁的。直到同步代码块结束,这把锁才会释放。
3、假设t1已经占有这把锁,此时t2也遇到synchronized关键字,也会占有后面共享对象
的这把锁,结果这把锁被t1占有,t2只能在同步代码块外面等待t1的结束,直到t1把同步
代码块执行结束了,t1会归还这把锁,此时t2终于等到这把锁,然后t2占有这把锁之后,
进入同步代码块执行程序。
这样就达到了线程排队执行。
这里需要注意的是:这个共享对象一定要选好了。这个共享对象一定是你需要排队执行的这
些线程对象所共享的。
*/
synchronized(this){
double before = this.getBalance();
double after = before - money;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.setBalance(after);
}
}
}
synchronized理解
package com.bjpowernode.javase.threadsafe2;
public class Account {
// 账号
private String actno;
// 余额
private double balance;
// 对象
Object obj = new Object(); // 实例变量。
// Account对象是多线程共享的,Account对象中的实例变量obj也是共享的。
public Account() {
}
public Account(String actno, double balance) {
this.actno = actno;
this.balance = balance;
}
public String getActno() {
return actno;
}
public void setActno(String actno) {
this.actno = actno;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
// 取款的方法
public void withdraw(double money){
// 以下这几行代码必须是线程排队的,不能并发。
// 一个线程把这里的代码全部执行结束之后,另一个线程才能进来。
/*
线程同步机制的语法是:
synchronized(){
// 线程同步代码块。
}
synchronized后面小括号中传的这个“数据”是相当关键的。
这个数据必须是多线程共享的数据。才能达到多线程排队的效果。
()中写什么?
那要看你想让哪些线程同步。
假设t1、t2、t3、t4、t5,有5个线程,
你只希望t1 t2 t3排队,t4 t5不需要排队。怎么办?
你一定要()中写一个t1 t2 t3共享的对象,而这个
对象对于t4 t5来说不是共享的。
这里的共享对象是:账户对象。
账户对象是共享的,那么this就是共享的。
不一定是this,这里只要是多线程共享的那个对象就行。
在java语言中,任何一个对象都有“一把锁”,其实这把锁就是标记。(只是把它叫做锁。)
100个对象,100把锁。1个对象1把锁。
以下代码的执行原理?
1、假设t1和t2线程并发,开始执行以下代码的时候,肯定有一个先一个后。
2、假设t1先执行了,遇到了synchronized,这个时候自动找“后面共享对象”的对象锁,
找到之后,并占有这把锁,然后执行同步代码块中的程序,在程序执行过程中一直都是占
有这把锁的。直到同步代码块结束,这把锁才会释放。
3、假设t1已经占有这把锁,此时t2也遇到synchronized关键字,也会占有后面共享对象
的这把锁,结果这把锁被t1占有,t2只能在同步代码块外面等待t1的结束,直到t1把同步
代码块执行结束了,t1会归还这把锁,此时t2终于等到这把锁,然后t2占有这把锁之后,
进入同步代码块执行程序。
这样就达到了线程排队执行。
这里需要注意的是:这个共享对象一定要选好了。这个共享对象一定是你需要排队执行的这
些线程对象所共享的。
*/
Object obj2 = new Object();
synchronized(this){
//synchronized(obj){ // 可以,Account对象是多线程共享的,Account对象中的实例变量obj也是共享的。
//synchronized(obj2){ // 这样编写就不安全了。因为obj2不是共享对象。
//synchronized ("abc"){ // "abc"在字符串常量池当中。可以,但是所有线程都会同步,t1 t2 t3 t4 t5线程都会同步。
// Object o = null;
// synchronized (o){
double before = this.getBalance();
double after = before - money;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.setBalance(after);
}
}
}
哪些变量有线程安全问题
- 实例变量:在堆中。
- 静态变量:在方法区。
- 局部变量:在栈中。
- 以上三大变量中:
- 局部变量永远都不会存在线程安全问题。
- 因为局部变量不共享。(一个线程一个栈)
- 局部变量在栈中。所以局部变量永远都不会共享。
- 实例变量在堆中,堆只有1个。
- 静态变量在方法区中,方法区只有1个。
- 堆和方法区都是多线程共享的,所以可能存在线程安全问题。
- 常量不会有线程安全问题,因为常量不可修改。
扩大synchronized范围
- 取消withdraw()中的synchronized
// synchronized (o){
double before = this.getBalance();
double after = before - money;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.setBalance(after);
//}
- 重写run()方法,增加synchronized
public void run(){
// run方法的执行表示取款操作。
// 假设取款5000
double money = 5000;
// 取款
//synchronized (this){ // this不是共享对象,this指的是线程对象,非账户对象
synchronized(act){
act.withdraw(money);
}
System.out.println(Thread.currentThread().getName() + "对" + act.getActno() + "取款" + money + "成功,余额" + act.getBalance());
}
synchronized出现在实例方法中
// 取款的方法
/**
* 在实例方法上可以使用synchronized吗?可以
* synchronized出现在实例方法上,一定锁的是this。
* 没得挑,只能是this。不是是其他对象。
* 所以这种方式不灵活。
*
* 另外还有一个缺点:synchronized出现在实例方法上,
* 表示整个方法体都需要同步,可能会无故扩大同步的范围,
* 导致程序的执行效率降低。所以这种方式不常用。
*
* synchronized使用在实例方法上有什么优点?
* 代码写的少了。节俭了。
*
* 如果共享的对象就是this,并且需要同步的代码块是整个方法体,
* 建议使用这种方式。
*
* 如果使用局部变量的话:
* 建议使用:StringBuilder。
* 因为局部变量不存在线程安全问题。选择StringBuilder。
* StringBuffer效率比较低。
*
* ArrayList是非线程安全的。
* Vector是线程安全的。
* HashMap HashSet是非线程安全的。
* Hashtable是线程安全的。
*/
public synchronized void withdraw(double money){
double before = this.getBalance();
double after = before - money;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.setBalance(after);
}
synchronized的三种写法
/**
synchronized有三种写法:
第一种:同步代码块
灵活
synchronized(线程共享对象){
同步代码块;
}
第二种:在实例方法上使用synchronized
表示共享对象一定是this
并且同步代码块是整个方法体。
第三种:在静态方法上使用synchronized
表示找类锁。
类锁永远只有1把。
就算创建了100个对象,那类锁也只有一把。
对象锁:1个对象1把锁,100个对象100把锁。
类锁:100个对象,也可能只是1把类锁。
*/
synchronized面试题1
package com.bjpowernode.javase.exam1;
// 面试题:doOther方法的执行需不需要等待doSome方法的结束?
// 不需要,因为doOther方法上没有synchronized,不需要排队
public class Exam01 {
public static void main(String[] args) {
MyClass mc = new MyClass();
MyThread t1 = new MyThread(mc);
MyThread t2 = new MyThread(mc);
t1.setName("t1");
t2.setName("t2");
t1.start();
try {
Thread.sleep(1000); // 这个睡眠的作用是:为了保证t1线程先执行。
} catch (InterruptedException e) {
e.printStackTrace();
}
t2.start();
}
}
class MyThread extends Thread{
private MyClass mc;
public MyThread(MyClass mc){
this.mc = mc;
}
public void run(){
if(Thread.currentThread().getName().equals("t1")){
mc.doSome();
}
if(Thread.currentThread().getName().equals("t2")){
mc.doOther();
}
}
}
class MyClass{
public synchronized void doSome(){
System.out.println("doSome begin");
try {
Thread.sleep(1000 * 10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("doSome over");
}
public void doOther(){
System.out.println("doOther begin");
System.out.println("doOther over");
}
}
synchronized面试题2
package com.bjpowernode.javase.exam2;
// 面试题:doOther方法的执行需不需要等待doSome方法的结束?
// 需要,doSome将this锁拿走了,mc对象只有一个,需要等待排队。
public class Exam02 {
public static void main(String[] args) {
MyClass mc = new MyClass();
MyThread t1 = new MyThread(mc);
MyThread t2 = new MyThread(mc);
t1.setName("t1");
t2.setName("t2");
t1.start();
try {
Thread.sleep(1000); // 这个睡眠的作用是:为了保证t1线程先执行。
} catch (InterruptedException e) {
e.printStackTrace();
}
t2.start();
}
}
class MyThread extends Thread{
private MyClass mc;
public MyThread(MyClass mc){
this.mc = mc;
}
public void run(){
if(Thread.currentThread().getName().equals("t1")){
mc.doSome();
}
if(Thread.currentThread().getName().equals("t2")){
mc.doOther();
}
}
}
class MyClass{
public synchronized void doSome(){
System.out.println("doSome begin");
try {
Thread.sleep(1000 * 10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("doSome over");
}
public synchronized void doOther(){
System.out.println("doOther begin");
System.out.println("doOther over");
}
}
synchronized面试题3
package com.bjpowernode.javase.exam3;
// 面试题:doOther方法的执行需不需要等待doSome方法的结束?
// 不需要,因为两种不同的对象锁,互不影响。
public class Exam03 {
public static void main(String[] args) {
MyClass mc1 = new MyClass();
MyClass mc2= new MyClass();
MyThread t1 = new MyThread(mc1);
MyThread t2 = new MyThread(mc2);
t1.setName("t1");
t2.setName("t2");
t1.start();
try {
Thread.sleep(1000); // 这个睡眠的作用是:为了保证t1线程先执行。
} catch (InterruptedException e) {
e.printStackTrace();
}
t2.start();
}
}
class MyThread extends Thread{
private MyClass mc;
public MyThread(MyClass mc){
this.mc = mc;
}
public void run(){
if(Thread.currentThread().getName().equals("t1")){
mc.doSome();
}
if(Thread.currentThread().getName().equals("t2")){
mc.doOther();
}
}
}
class MyClass{
public synchronized void doSome(){
System.out.println("doSome begin");
try {
Thread.sleep(1000 * 10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("doSome over");
}
public synchronized void doOther(){
System.out.println("doOther begin");
System.out.println("doOther over");
}
}
synchronized面试题4
package com.bjpowernode.javase.exam4;
// 面试题:doOther方法的执行需不需要等待doSome方法的结束?
// 需要,因为静态方法是类锁,类锁不管创建了几个对象,类锁只有一把。
public class Exam04 {
public static void main(String[] args) {
MyClass mc1 = new MyClass();
MyClass mc2= new MyClass();
MyThread t1 = new MyThread(mc1);
MyThread t2 = new MyThread(mc2);
t1.setName("t1");
t2.setName("t2");
t1.start();
try {
Thread.sleep(1000); // 这个睡眠的作用是:为了保证t1线程先执行。
} catch (InterruptedException e) {
e.printStackTrace();
}
t2.start();
}
}
class MyThread extends Thread{
private MyClass mc;
public MyThread(MyClass mc){
this.mc = mc;
}
public void run(){
if(Thread.currentThread().getName().equals("t1")){
mc.doSome();
}
if(Thread.currentThread().getName().equals("t2")){
mc.doOther();
}
}
}
class MyClass{
// synchronized出现在静态方法上是找类锁。
public synchronized static void doSome(){
System.out.println("doSome begin");
try {
Thread.sleep(1000 * 10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("doSome over");
}
public synchronized static void doOther(){
System.out.println("doOther begin");
System.out.println("doOther over");
}
}
死锁概述
package com.bjpowernode.javase.deadlock;
/*
死锁代码要会写。
一般面试官要求你会写。
只有会写,才会在以后的开发中注意这个事儿。
因为死锁很难调试。
synchronized在开发中最好不要嵌套使用,容易发生死锁现象。
*/
public class DeadLock {
public static void main(String[] args) {
Object o1 = new Object();
Object o2 = new Object();
// t1,t2线程共享o1和o2
Thread t1 = new MyThread1(o1, o2);
Thread t2 = new MyThread2(o1, o2);
t1.start();
t2.start();
}
}
class MyThread1 extends Thread{
Object o1;
Object o2;
public MyThread1(Object o1, Object o2){
this.o1 = o1;
this.o2 = o2;
}
public void run(){
synchronized (o1){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (o2){
}
}
}
}
class MyThread2 extends Thread{
Object o1;
Object o2;
public MyThread2(Object o1, Object o2){
this.o1 = o1;
this.o2 = o2;
}
public void run(){
synchronized (o2){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (o1){
}
}
}
}
开发中应该怎么解决线程安全问题
/*
是一上来就选择线程同步吗?synchronized
不是,synchronized会让程序的执行效率降低,用户体验不好。
系统的用户吞吐量降低。用户体验差。在不得已的情况下再选择
线程同步机制。
第一种方案:
尽量使用局部变量代替“实例变量和静态变量”
第二种方案:
如果必须是实例变量,那么可以考虑创建多个对象,这样
实例变量的内存就不共享了。(一个线程对应1个对象,
100个线程对应100个对象,对象不共享,就没有数据安全
问题了。)
第三种方案:
如果不能使用局部变量,对象也不能创建多个,这个时候就
只能选择synchronized了。线程同步机制。
*/
守护线程概述
/*
java语言中线程分为两大类:
一类是:用户线程
一类是:守护线程(后台线程)
其中具有代表性的就是:垃圾回收线程(守护线程)
守护线程的特点是:
一般守护线程是一个死循环,所有的用户线程只要结束,
守护线程自动结束。
注意:主线程main方法是一个用户线程。
守护线程用在什么地方呢?
每天00:00的时候系统数据自动备份。
这个需要使用到定时器,并且我们可以将定时器设置为守护线程。
一直在那里看着,没到00:00的时候就备份一次。所有的用户线程
如果结束了,守护线程自动退出,没有必要进行数据备份了。
*/
package com.bjpowernode.javase.thread;
/*
守护线程
*/
public class ThreadTest14 {
public static void main(String[] args) {
Thread t = new BakDataThread();
t.setName("备份数据的线程");
// 启动线程之前,将线程设置为守护线程
t.setDaemon(true);
t.start();
// 主线程:用户线程
for(int i = 0; i < 10; i ++) {
System.out.println(Thread.currentThread().getName() + "--->" + i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class BakDataThread extends Thread{
public void run(){
int i = 0;
// 即使是死循环,但由于该线程是守护者,当用户线程结束,守护线程自动终止。
while(true){
System.out.println(Thread.currentThread().getName() + "---->" + (++i));
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
定时器
/*
定时器的作用:
间隔特定的时间,执行特定的程序。
每周要进行银行账户的总账操作。
每天要进行数据的备份操作。
在实际的开发中,每隔多久执行一段特定的程序,这种需求是很常见的。
那么在java中其实可以采用多种方式实现:
可以使用sleep方法,睡眠,设置睡眠时间,每到这个时间点醒来,执行
任务。这种方式是最原始的定时器。(比较low)
在java的类库中已经写好了一个定时器:java.util.Timer,可以直接拿来用。
不过,这种方式在目前的开发中也很少用,因为现在有很多高级框架都是支持定时
任务的。
在实际的开发中,目前使用较多的是Spring框架中提供的SpringTask框架,
这个框架只要进行简单的配置,就可以完成定时器的任务。
*/
实现线程的第三种方式
/*
实现Callable接口。(JDK8新特性)
这种方式实现的线程可以获取线程的返回值。
之前讲解的那两种方式是无法获取线程返回值的,因为run方法返回void。
思考:
系统委派一个线程去执行一个任务,该线程执行完任务之后,可能
会有一个执行结果,我们怎么能拿到这个执行结果呢?
使用第三种方式:实现Callable接口方式。
*/
package com.bjpowernode.javase.thread;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask; // JUC包下的,属于java的并发包,老JDK中没有这个包。新特性。
/*
实现线程的第三种方式:
实现Callable接口
这种方式的优点:可以获取到线程的执行结果。
这种方式的缺点:效率比较低,在获取t线程执行结果的时候,当前线程受阻塞,效率比较低。
*/
public class ThreadTest15 {
public static void main(String[] args) throws Exception{
// 第一步:创建一个“未来任务类”对象
// 参数非常重要,需要给一个Callable接口实现类对象。
FutureTask task = new FutureTask(new Callable() {
@Override
public Object call() throws Exception { // call()方法相当于run方法。只不过这有返回值。
// 线程执行一个任务,执行之后可能会有一个执行结果
// 模拟执行
System.out.println("call method begin!");
Thread.sleep(1000 * 10);
System.out.println("call method end!");
int a = 100;
int b = 200;
return a + b; // 自动装箱(300结果编程Integer)
}
});
// 创建线程类对象
Thread t = new Thread(task);
// 启动线程
t.start();
// 这里是main方法,这是在主线程中
// 在主线程中,怎么获取t线程的返回结果
// get()方法的执行会导致“当前线程堵塞”
Object obj = task.get();
System.out.println("线程的执行结果" + obj);
// main方法这里的程序要想执行必须等待get()方法的结束
// 而get()方法可能需要很久。因为get()方法是为了拿到一个线程的执行结果
// 另一个线程执行是需要时间的。
System.out.println("Hello World!");
}
}
wait和notify的概述
/*
关于Object类中的wait和notify方法。(生产者和消费者模式!)
第一:wait和notify方法不是线程对象的方法,是java中任何一个java对象
都有的方法,因为这两个方式是Object类自带的。
wait方法和notify方法不是通过线程对象调用,
不是这样的:t.wait(),也不是这样的:t.notify()..不对。
第二:
wait()方法作用?
Object o = new Object();
o.wait();
表示:
让正在o对象上活动的线程进入等待状态,无期限等待,
直到被唤醒为止。
o.wait()方法的调用,会让“当前线程(正在o对象上
活动的线程)”进入等待状态
第三:notify()方法作用?
Object o = new Object();
o.notify(;
表示:
唤醒正在o对象上等待的线程。
还有一个notifyAll()方法:
这个方法是唤醒o对象上处于等待的所有线程。
*/
生产者和消费者模式
package com.bjpowernode.javase.thread;
import java.util.ArrayList;
import java.util.List;
/**
* 1、使用wait方法和notify方法实现“生产者和消费者模式”
* 2、什么是“生产者和消费者模式”?
* 生产线程负责生产,消费线程负责消费。
* 生产线程和消费线程要达到均衡。
* 这是一种特殊的业务需求,在这种特殊的情况下需要使用wait方法和notify方法。
* 3、wait和notify方法不是线程对象的方法,是普通java对象都有的方法。
* 4、wait和notify方法建立在线程同步的基础上。因为多线程要同时操作一个仓库。有线程安全问题。
* 5、wait方法作用:o.wait()让正在o对象上活动的线程t进入等待状态,并且释放t线程之前占有的o对象的锁。
* 6、notify方法作用:o.notify()让正在o对象上等待的线程唤醒,只是通知,不会释放o对象上之前占有的锁。
* 7、模拟这样一个需求:
* 仓库我们采用List集合。
* List集合中假设只能存储1个元素。
* 1个元素就表示仓库满了。
* 如果List集合的元素个数是0,就表示仓库空了。
* 保证List集合中永远都是最多存储1个元素。
*
* 必须做到这种效果:生产1个消费1个
*/
public class ThreadTest16 {
public static void main(String[] args) {
// 创建1个仓库对象,共享的
List list = new ArrayList();
// 创建两个线程对象
// 生产者线程
Thread t1 = new Thread(new Producer(list));
t1.setName("生产者线程");
// 消费者线程
Thread t2 = new Thread(new Consumer(list));
t2.setName("消费者线程");
t1.start();
t2.start();
}
}
// 生产线程
class Producer implements Runnable{
// 仓库
private List list;
public Producer(List list){
this.list = list;
}
public void run(){
// 一直生产(使用死循环模拟一直生产)
while(true){
// 给仓库对象list加锁。
synchronized (list){
if(list.size() > 0){ // 大于0说明仓库中已经有1个元素了。若仓库中存放10个元素,即生产10个,消费10个,可直接将>0换成>9即可。
// 当前线程进入等待状态,并且释放Producer之前占有的list集合的锁。
try {
list.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 程序能执行到这里说明仓库是空的,可以生产
Object obj = new Object();
list.add(obj);
System.out.println(Thread.currentThread().getName() + "---->" + obj);
// 唤醒消费者进行消费
list.notify();
}
}
}
}
// 消费线程
class Consumer implements Runnable{
// 仓库
private List list;
public Consumer(List list){
this.list = list;
}
public void run(){
// 一直消费
while(true){
synchronized (list){
if(list.size() == 0){ // 代表仓库已经空了。
// 消费者线程等待,释放掉list集合的锁。
try {
list.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 程序能够执行到此处说明仓库中有数据,进行消费。
Object obj = list.remove(0);
System.out.println(Thread.currentThread().getName() + "---->" + obj);
// 唤醒生产者生产
list.notify();
}
}
}
}