1.Synchronized 关键字的使用
- 修饰一个代码块,被修饰的代码块称为同步代码块,作用范围是大括号{}括起来的代码;
- 修饰一个方法,被修饰的方法称为同步方法,其作用范围是整个方法;
修饰代码块
注:this 表示锁是当前对象,锁可以自定义,但是要实现同步必须是同一把锁才可以。
public void method()
{
synchronized(this) {
// todo some thing
}
}
- 修饰方法
public synchronized void method()
{
// todo some thing
}
1.1 修饰代码块
/**
* synchrosnized 关键字测试
* 同步代码块
* @author 码农猿
*/
public class SynchronizedDemo1 implements Runnable {
/**
* 全局变量
* 创建一个计数器
*/
private static int counter = 1;
@Override
public void run() {
Date startDate = DateUtil.date();
synchronized (this) {
for (int i = 0; i < 5; i++) {
try {
System.out.println("线程 :" + Thread.currentThread().getName() + " 当前计数器 :" + (counter++));
System.out.println("开始时间 :" + startDate + " 当前时间 :" + DateUtil.date());
System.out.println();
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public static void main(String[] args) {
SynchronizedDemo1 syncThread = new SynchronizedDemo1();
Thread thread1 = new Thread(syncThread, "sync-thread-1");
Thread thread2 = new Thread(syncThread, "sync-thread-2");
thread1.start();
thread2.start();
}
}
- 结果图示
结果说明
当两个并发线程(thread1和thread2)访问同一个对象(syncThread)中的synchronized代码时
在同一时刻只能有一个线程得到执行,
另一个线程受阻塞,必须等待当前线程执行完这个代码块以后才能执行该代码块。Thread1和thread2是互斥的,因为在执行synchronized代码块时会锁定当前的对象,只有执行完该代码块才能释放该对象锁,下一个线程才能执行并锁定该对象。
稍加改动
public static void main(String[] args) {
SynchronizedDemo1 syncThread1 = new SynchronizedDemo1();
SynchronizedDemo1 syncThread2 = new SynchronizedDemo1();
Thread thread1 = new Thread(syncThread1, "sync-thread-1");
Thread thread2 = new Thread(syncThread2, "sync-thread-2");
thread1.start();
thread2.start();
}
从图上可以看出来,两个线程都是新建一个对象去执行的,所以锁也是两个,所以执行方式是同时执行了。
1.2修饰普通方法
Synchronized修饰一个方法很简单,就是在方法的前面加synchronized关键字,
修饰方法和修饰一个代码块类似,只是作用范围不一样,修饰代码块是大括号括起来的范围,而修饰方法范围是整个函数。
将第一个个实例中的run方法改成如下的方式,实现的效果一样。
@Override
public synchronized void run() {
Date startDate = DateUtil.date();
for (int i = 0; i < 5; i++) {
try {
System.out.println("线程 :" + Thread.currentThread().getName() + " 当前计数器 :" + (counter++));
System.out.println("开始时间 :" + startDate + " 当前时间 :" + DateUtil.date());
System.out.println();
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
注意: 实现同步是要很大的系统开销作为代价的,甚至可能造成死锁,所以尽量避免无谓的同步控制
2.并发协作-管程法
- 协作模型:生产者消费者实现方式 1、管程法
- 借助缓冲区
this.wait();//线程阻塞 生产者通知消费 解决阻塞
this.notifyAll();//存在空间 唤醒对方
package com;
/**
* 协作模型:生产者消费者实现方式 1、管程法
* 借助缓冲区
* @author AnQi
* @date 2020/3/12 17 04:35
* @description
*/
public class Main {
public static void main(String[] args) {
SynContainer container = new SynContainer();
new Productor(container).start();
new Consumer(container).start();
}
}
//生产者
class Productor extends Thread{
SynContainer container;
public Productor(SynContainer container){
this.container=container;
}
@Override
public void run() {
//生产
for (int i = 0;i<100;i++){
System.out.println("生产-->"+i+"个馒头");
container.push(new Steamedbun(i));
}
}
}
//消费者
class Consumer extends Thread{
SynContainer container;
public Consumer(SynContainer container){
this.container=container;
}
@Override
public void run() {
//消费
for (int i = 0;i<100;i++){
System.out.println("消费-->"+container.pop().id+"个馒头");
}
}
}
//缓冲区
class SynContainer{
Steamedbun[] buns=new Steamedbun[10];//存储容器
int count = 0;//计数器
//存 (生产)
public synchronized void push(Steamedbun bun){
//何时能生产 容器存在空间
//不能生产
if(count == buns.length){
try {
this.wait();//线程阻塞 消费者通知生产 解除
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//有空间 可以生产
buns[count] = bun;
count++;
//存在数据 可以通知消费
this.notifyAll();
}
//取 (消费)
public synchronized Steamedbun pop(){
//何时消费 容器中是否存在数据
//没有数据 等待
if(count == 0 ){
try {
this.wait();//线程阻塞 生产者通知消费 解决阻塞
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//存在数据可以消费
count--;
Steamedbun bun = buns[count];
this.notifyAll();//存在空间 唤醒对方
return bun;
}
}
//馒头(数据)
class Steamedbun{
int id;
public Steamedbun(int id) {
this.id = id;
}
}
3.多线程----定时调度
3.1 java实现简单的定时调度--Timer
一)、Timer
1、Timer实现任务调度的核心类是Timer和TimerTask (本身就是一个线程)
1)、创建一个TimerTask的子类,实现自己的run方法(自定义所要调度的任务);
2)、Timer负责设定TimerTask相对于当前多长时间执行此任务和执行任务的间隔。
2、原理:Timer将接受的任务丢到自己的TaskList中,TaskList按照Task的最初执行时间进行排列。
3、缺点:所有任务都是由一个线程来调度,因此所有任务都是串行执行的,同一时间只能有一个任务执行,前一个任务的延迟会影响到之后的任务。
public class Main extends TimerTask {
private String jobName="";
public Main(String jobName) {
super();
this.jobName=jobName;
}
@Override
public void run() {
System.out.println("excute :"+ jobName);
}
public static void main(String[] args) {
Timer timer = new Timer();
long delay1 = 1*1000;
long peroid1 = 1000;
// 从现在开始过1秒钟之后,每隔1秒钟执行一次job1(schedule:预定计划)
timer.schedule(new Main("job1"), delay1,peroid1);
long delay2 = 5*1000;
long peroid2 = 2000;
// 从现在开始过2秒钟之后,每隔2秒钟执行一次job2
timer.schedule(new Main("-----job2"), delay2, peroid2);
}
}
3.2 ScheduleExecutor任务安排器
1、鉴于Timer的缺陷,Java5推出了基于线程池设计的ScheduleExecutor.每个被调度的任务,都对应开启了一个线程,因此任务并发执行,相互之间不受影响;
2、当任务执行时间带来时候,任务安排器ScheduleExecutor才会真正的启动一个线程,其余时间ScheduleExecutor都在轮询任务状态。
public class ScheduleExecutor implements Runnable {
private String jobName = "";
public ScheduleExecutor(String jobName) {
super();
this.jobName = jobName;
}
@Override
public void run() {
System.out.println("execute :"+ jobName);
}
public static void main(String[] args) {
ScheduledExecutorService service = Executors.newScheduledThreadPool(10);
long initialDelay1 = 1;
long period1 = 1;
// 从现在开始1秒之后,每隔1一秒钟执行一次job1
service.scheduleAtFixedRate(new ScheduleExecutor("job1"), initialDelay1, period1, TimeUnit.SECONDS);
long initialDelay2 = 2;
long period2 = 2;
// 从现在开始2秒之后,每隔2秒钟执行一次job2
service.scheduleAtFixedRate(new ScheduleExecutor("----job2"), initialDelay2, period2, TimeUnit.SECONDS);
}
}
总结:
1、通过上面几种任务调度比较,各有优缺点。简单单任务程用Timer;简单多任务用简单多任务用Executors.newScheduledThreadPool(10)线程池;又比如说周一到周五每天下午15:13:14这种比较复杂的定时调度任务用Quartz和JCrontab,当然有web项目则JCrontab没得说