1.静态方法
static void yield() 让位方法:暂停当前正在执行的线程对象,并执行其他线程
注意:
yield() 方法不是阻塞方法,而是把当前线程让位,让给其他线程使用,方法的执行会让当前线程从运行状态回到就绪状态,回到就绪状态还可能会抢占CPU时间片
public class Thread_2_Yield {
public static void main(String[] args) {
Thread t1 = new Processor_02();
// 启动线程
t1.start();
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName()+" : "+i);
}
}
}
class Processor_02 extends Thread{
@Override
public void run() {
for (int i = 0; i < 10; i++) {
if (i % 2 == 0) {
Thread.yield();
}
System.out.println(getName()+" : "+i);
}
}
}
2 成员方法
void setpriority (int newPriority) 设置线程优先级
get getPriority() 获取线程优先级
注意:
最低优先级是1 默认优先级是5 最高优先级是10
void join() 线程合并
public class Thread_1_Join {
public static void main(String[] args) {
Thread t1 = new Thread(new Processer_01());
Thread t2 = new Thread(new Processer_01());
t1.setName("t1");
t2.setName("t2");
t1.start();
t2.start();
try {
// 执行到join的时候,因为是t1调用的,所以 main之后的代码,必须等t1执行完之后才能执行
t1.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName() + " : " + i);
}
}
}
class Processer_01 implements Runnable {
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName() + " : " + i);
}
}
}
2. synchronized线程同步
2.1 synchronized的三种应用方式
public class Thread_3_Synchronization {
public static void main(String[] args) {
A a = new A(10);
A a1 = new A(11);
Thread t1 = new Thread(new Processor_03(a));
Thread t2 = new Thread(new Processor_03(a));
t1.setName("t1");
t2.setName("t2");
t1.start();
t2.start();
}
}
class Processor_03 implements Runnable {
A a;
public Processor_03(A a) {
super();
this.a = a;
}
@Override
public void run() {
a.m1();
}
}
class A {
int i;
// 方法锁
// public synchronized void m1() {
public void m1() {
System.out.println("-----------");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 代码块锁
synchronized(this){
i++;
System.out.println(Thread.currentThread().getName() + " : " + i);
}
System.out.println("==========");
}
public A(int i) {
super();
this.i = i;
}
}
synchronized关键字最主要有以下3种应用方式
- 修饰成员方法，作用于当前成员加锁，进入同步代码前要获得当前成员的锁
- 修饰静态方法，作用于当前类对象加锁，进入同步代码前要获得当前类对象的锁
- 修饰代码块，指定加锁对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁。
线程同步机制的语法是
synchronized(){} 语句块解决
synchronized(对象){ // 这种方式是把该对象中所有加锁的成员方法和代码块锁全部锁定
同步代码;
}
synchronized(类名.class){ // 把该类中所有加锁的静态方法和代码块锁全部锁定
同步代码;
}
synchronized 后面的小括号中传的这个 “数据”是相当关键 的
这个数据必须是多线程共享的数据。才能达到线程排队。
( ) 括号中具体写什么? 那就看想让哪些线程同步
假设t1、t2、t3、t4、t5，有5个线程。现在只希望t1、t2、t3排队，t4、t5不需要排队。
这时就要在()中写一个t1、t2、t3共享的对象，而这个对象对于t4、t5来说不是共享的。
//this,当前实例对象锁
synchronized(this){
for(int j=0;j<1000000;j++){
i++;
}
}
//class对象锁
synchronized(AccountingSync.class){
for(int j=0;j<1000000;j++){
i++;
}
}
在java语言中,任何一个对象都有“一把锁”,其实这把锁就是标记。( 只是把它叫做锁。)
100个对象, 10把锁。1个对象1把锁。
线程同步的代码的执行原理?
1、假设t1和t2线程并发,开始执行以下代码的时候，肯定有一个先一个后。
2、假设t1先执行了,遇到了synchronized ,这个时候自动找“后面共享对象”的对象锁,找到之后，并占有这把锁，然后执行同步代码块中的程序，在程序执行过程中一直都是占有这把锁的。直到同步代码块代码结束,这把锁才会释放。
3、假设t1已经占有这把锁,此时2也遇到synchronized关键字,也会去占有后面共享对象的这把锁,结果这把锁被t1占有, t2只能在同步代码块外面等待t1的结束,直到t1把同步代码块执行结束了, t1会归还这把锁，此时t2终于等到这把锁,然后t2占有这把锁之后，进入同步代码块执行程序。
这样就达到了线程排队。
2.3 synchronized作用于成员方法
被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；
如果多个线程访问同一个对象的实例变量，可能出现非线程安全问题。
使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候 ,其他线程只能在方法外等着.且共享对象一定是this，并且同步代码块是整个方法体。
synchronized public void doWork(){
// 需要同步操作的代码
}
创建了一个AccountingSync对象:
public class AccountingSync implements Runnable{
//共享资源(临界资源)
static int i=0;
public synchronized void increase(){
i++;
}
@Override
public void run() {
for(int j=0;j<1000000;j++){
increase();
}
}
public static void main(String[] args) throws InterruptedException {
AccountingSync instance=new AccountingSync();
Thread t1=new Thread(instance);
Thread t2=new Thread(instance);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(i);
}
}
2.4 synchronized作用于静态方法
表示找类锁。类锁永远只有一把。就算创建了100个对象，那类锁也只有一把。
- 对象锁：1个对象1把锁，100个对象100把锁。
- 类锁：100个对象，也可能只是1把类锁。
当synchronized作用于静态方法时，其锁就是当前类的class对象锁。由于静态成员不专属于任何一个实例对象，是类成员，因此通过class对象锁可以控制静态 成员的并发操作。需要注意的是如果一个线程A调用一个实例对象的非static synchronized方法，而线程B需要调用这个实例对象所属类的静态 synchronized方法，是允许的，不会发生互斥现象，因为访问静态 synchronized 方法占用的锁是当前类的class对象，而访问非静态 synchronized 方法占用的锁是当前实例对象锁，看如下代码
创建了两个AccountingSyncClass对象：
public class AccountingSyncClass implements Runnable{
static int i=0;
public static synchronized void increase(){
i++;
}
@Override
public void run() {
for(int j=0;j<1000000;j++){
increase();
}
}
public static void main(String[] args) throws InterruptedException {
//new新实例
Thread t1=new Thread(new AccountingSyncClass());
//new心事了
Thread t2=new Thread(new AccountingSyncClass());
//启动线程
t1.start();t2.start();
t1.join();t2.join();
System.out.println(i);
}
}
由于synchronized关键字修饰的是静态increase方法，与修饰实例方法不同的是，其锁对象是当前类的class对象。注意代码中的increase4Obj方法是实例方法，其对象锁是当前实例对象，如果别的线程调用该方法，将不会产生互斥现象，毕竟锁对象不同，但我们应该意识到这种情况下可能会发现线程安全问题(操作了共享静态变量i)。
3. java三大变量的线程安全
- 成员变量:在堆中。
- 静态变量:在方法区。
- 局部变量:在栈中。
以上三大变量中:
局部变量永远都不会存在线程安全问题。因为局部变量不共享。(一个线程一个栈。)
局部变量在栈中。所以局部变量永远都不会共享。
实例变量在堆中，堆只有1个。
静态变量在方法区中，方法区只有1个。
堆和方法区都是多线程共享的，所以可能存在线程安全问题。
局部变量+常量：不会有线程安全问题。
成员变量：可能会有线程安全问题。
public class Thread_6_DeadLock {
public static void main(String[] args) {
Object o1 = new Object();
Object o2 = new Object();
Thread t1 = new T1(o1,o2);
Thread t2 = new Thread(new T2(o1,o2));
t1.start();
t2.start();
}
}
class T1 extends Thread{
Object o1;
Object o2;
public T1(Object o1, Object o2) {
super();
this.o1 = o1;
this.o2 = o2;
}
@Override
public void run() {
synchronized (o1) {
System.out.println("t1已进入o1 准备进入后o2");
synchronized (o2) {
System.out.println( "t1 执行完成");
}
}
}
}
class T2 extends Thread{
Object o1;
Object o2;
public T2(Object o1, Object o2) {
super();
this.o1 = o1;
this.o2 = o2;
}
@Override
public void run() {
synchronized (o2) {
System.out.println("t2已进入o2 准备进入后o1");
synchronized (o1) {
System.out.println( "t2 执行完成");
}
}
}
}
一直是这样，synchronized在开发中最好不要嵌套使用。一不小心就会导致死锁现象的发生。
4.1代码块锁
public class Thread_4_Lock {
public static void main(String[] args) {
A1 a = new A1(10);
Thread t1 = new Thread(new Processor_4(a));
Thread t2 = new Thread(new Processor_4(a));
t1.setName("t1");
t2.setName("t2");
t1.start();
t2.start();
}
}
class Processor_4 implements Runnable {
A1 a;
public Processor_4(A1 a) {
super();
this.a = a;
}
@Override
public void run() {
a.m1();
}
}
class A1 {
int i;
// 创建锁对象
Lock lock = new ReentrantLock();
public void m1() {
System.out.println("-----------");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// synchronized (this) {
// 开始加锁
lock.lock();
i++;
System.out.println(Thread.currentThread().getName() + " : " + i);
// 解锁
lock.unlock();
// }
System.out.println("==========");
}
public A1(int i) {
super();
this.i = i;
}
}
5.定时器
5.1 定时器的概述
定时器的作用:
间隔特定的时间，执行特定的程序。
例如每周要进行银行账户的总账操作。
每天要进行数据的备份操作。
在实际的开发中，每隔多久执行一-段特定的程序，这种需求是很常见的,
那么在java中其实可以采用多种方式实现:
- 可以使用sleep方法，睡眠，设置睡眠时间，没到这个时间点醒来，执行任务。这种方式是最原始的定时器。(比较low)
- 在java的类库中已经写好了一个定时器: java. util.Timer,可以直接拿来用。不过，这种方式在目前的开发中也很少用，因为现在有很多高级框架都是支持定时任务的。
- 在实际的开发中，目前使用较多的是Spring框架中提供的springTask框架,这个框架只要进行简单的配置，就可以完成定时器的任务。
timer.schedule(定时任务，第一次执行时间，间隔多久执行一次);
也可以使用匿名内部类设定定时任务
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;
public class TimerTest {
public static void main(String[] args) throws Exception{
//创建定时器对象
Timer timer = new Timer();
//Timer timer = new Timer(true);//守护线程的方式
//指定定时任务
//timer.schedule(定时任务，第一次执行时间，间隔多久执行一次);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date firstTime = sdf.parse("2021-3-17 11:24:30");
timer.schedule(new LogTimerTask(),firstTime,1000*10);
}
}
//编写一个类
//假设这是一个记录日志的定时任务
class LogTimerTask extends TimerTask{
@Override
public void run() {
//编写需要执行的任务就行了。
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String strTime = sdf.format(new Date());
System.out.println(strTime +":成功完成第一次数据备份！");
}
}
结果:
6.关于Object类中的wait和notify方法
即生产者和消费者模式
public class Thread_7_Wait {
public static void main(String[] args) {
Num num = new Num();
Thread t1 = new PrintOdd(num);
Thread t2 = new PrintEven(num);
t1.setName("t1");
t2.setName("t2");
t1.start();
t2.start();
}
}
class PrintOdd extends Thread{
Num num;
public PrintOdd(Num num){
super();
this.num = num;
}
@Override
public void run() {
while(true){
num.PrintOdd();
}
}
}
class PrintEven extends Thread{
Num num;
public PrintEven(Num num) {
super();
this.num = num;
}
@Override
public void run() {
while(true){
num.PrintEven();
}
}
}
//业务类
class Num{
int count = 1;
public synchronized void PrintOdd(){
System.out.println(Thread.currentThread().getName()+":"+count);
count++;
//唤醒所有在当前对象中睡眠的线程
this.notifyAll();
try {
Thread.sleep(500);
// 挂起 交出该对象持有的锁,让其他线程可以执行
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public synchronized void PrintEven(){
System.out.println(Thread.currentThread().getName()+":"+count);
count++;
// 唤醒所有在当前对象中睡眠的线程
this.notifyAll();
try {
Thread.sleep(500);
// 挂起 交出该对象持有的锁,让其他线程可以执行
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
- 第一：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对象上处于等待的所有下线程
使用wait方法和notify方法实现“生产者和消费者模式”
什么是生产者和消费者模式？
生产线程负责生产，消费线程负责消费。
生产线程和消费线程要达到均衡。
这是一种特殊的业务需求,在这种特殊的情况下需要使用wait方法和notify方法。
wait和notify方法不是线程对象的方法,是普通java对象都有的方法。
wait方法和notify方法建立在线程同步的基础之上。因为多线程要同时操作一个仓库。有线程安全问题。
wait方法作用:o. wait()让正在o对象上活动的线程t进入等待状态，并且释放掉t线程之前占有的o对象的锁。
notify方法作用:o.notify()让正在o对象上等待的线程唤醒,只是通知,不会释放o对象上之前占有的锁。
模拟这样一个需求:
仓库我们采用list集合。
List集合中假设只能存储一个元素。
1个元素就表示仓库满了。
如果List集合中元素个数是0 ,就表示仓库空了。
import java.util.ArrayList;
import java.util.List;
public class ThreadTest13 {
public static void main(String[] args) {
//创建一个仓库对象，共享的
List list = new ArrayList();
//创建两个线程对象
//生产者线程
Thread t1 = new Thread(new Produce(list));
//消费者线程
Thread t2 = new Thread(new Consumer(list));
t1.setName("生产者线程");
t2.setName("消费者线程");
t1.start();
t2.start();
}
}
//生产线程
class Produce implements Runnable{
//仓库
private List list;
public Produce(List list){
this.list= list;
}
@Override
public void run() {
//一直生产(使用死循环来模拟一直生产)
while (true){
synchronized (list) {
if (list.size() > 0) {//大于0，说明仓库中已经有1个元素了
try {
//当前线程进入等待状态，并且释放Producer之前占有的list集合的锁
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;
}
@Override
public void run() {
//一直消费
while (true){
synchronized (list){
if (list.size() == 0){
//仓库已经空了
//释放掉Consumer之前占有的锁
try {
list.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//程序能够进行到此处说明仓库中有数据，进行消费。
Object obj = list.remove(0);
System.out.println(Thread.currentThread().getName() + "-->" + obj);
//唤醒生产者生产
list.notify();
}
}
}
}
总结终于搞定,开始搞作业,冲就完了!!!
