多线程(三) 并发—同步处理

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没得说