synchronized

notifyfall

改进后的代码  

通过对lockObj对象加锁，实现互斥   把关键代码放入synchronized块中

通过对lockObj对象加锁，实现互斥

构造锁对象

111111111

同步：通信机制

private final Object lockObj=new Object();//锁

synchronized(lockObj){

lockObj.wait();//保证条件不满足时任务都会被条件阻挡，而不会继续竞争处理器资源，把当前对象置于等待集合中waitset

lockObj.notifyAll();//唤醒所有在等待的线程

需要互斥的关键代码

}

1、一个线程告诉其他线程某些消息----通信。 

2、多个线程不能同时使用某个资源----互斥。

3、synchronized锁定互斥资源。 

4、while(energyBoxes[from]<amount){lockObj.wait();}  

     while循环保证条件不满足时，线程不会一直去请求锁，提高系统性能，它会在Wait Set中等待 

5、lockObj.notifyAll()；唤醒所有等待资源的线程。等待池的对象是不会竞争锁的，当notifyAll后，等待池中的线程会被唤醒进入到该线程的锁池中重新竞争对象锁，重新获得锁后的对象会从wait后继续执行代码，其他对象会被阻塞，而不是wait。被阻塞的对象会等待下一次被唤醒（notify、notifyAll）。另外，notify不是线程安全的，notifyAll才是。

6.同步：wait()+notify() 方法。

一、线程的特点：
进程是资源分配的最小单位，一个进程中有1—n个线程，线程共享资源，同一时刻只能有一个线程占领CPU
二、多线程：之间争用资源，多线程之间同步与互斥
1,多线程之间的互斥（加锁实现）：同一时间，只能有一个线程访问临界区（防止线程之间争用条件造成的“能量损失”）[对该临界资源进行加锁，表示现在只能由该线程进行访问]
2,多线程之间的同步（线程的等待和唤醒：wait()+notifyAll()）：通信机制；一个线程完成，以某种方式通知其他线程可以访问临界区
3,锁：private final Object lockObj=new Object();
三、重要的话
线程之间的互斥：通过加锁实现：线程访问临界区的代码放在一个代码块中，加锁实现
线程之间的同步：通过wait（）+notify（）的通信机制来实现
wait()和notifyAll()是在线程同步的时候使用的一对方法

1、一个线程告诉其他线程某些消息----通信。 

2、多个线程不能同时使用某个资源----互斥。

3、synchronized锁定互斥资源。 

4、while(energyBoxes[from]<amount){lockObj.wait();}  

     while循环保证条件不满足时，线程不会一直去请求锁，提高系统性能，它会在Wait Set中等待 

5、lockObj.notifyAll()；唤醒所有等待资源的线程。等待池的对象是不会竞争锁的，当notifyAll后，等待池中的线程会被唤醒进入到该线程的锁池中重新竞争对象锁，重新获得锁后的对象会从wait后继续执行代码，其他对象会被阻塞，而不是wait。被阻塞的对象会等待下一次被唤醒（notify、notifyAll）。另外，notify不是线程安全的，notifyAll才是。

6.同步：wait()+notify() 方法。

一、线程的特点：
进程是资源分配的最小单位，一个进程中有1—n个线程，线程共享资源，同一时刻只能有一个线程占领CPU
二、多线程：之间争用资源，多线程之间同步与互斥<br>
1,多线程之间的互斥（加锁实现）：同一时间，只能有一个线程访问临界区（防止线程之间争用条件造成的“能量损失”）[对该临界资源进行加锁，表示现在只能由该线程进行访问]<br>
2,多线程之间的同步（线程的等待和唤醒：wait()+notifyAll()）：通信机制；一个线程完成，以某种方式通知其他线程可以访问临界区<br>
3,锁：private final Object lockObj=new Object();

synchronized（lockObj） {}线程互斥

三、重要的话
线程之间的互斥：通过加锁实现：线程访问临界区的代码放在一个代码块中，加锁实现
线程之间的同步：通过wait（）+notify（）的通信机制来实现
wait()和notifyAll()是在线程同步的时候使用的一对方法

线程同步机制，及优化方法

一、线程的特点：
进程是资源分配的最小单位，一个进程中有1—n个线程，线程共享资源，同一时刻只能有一个线程占领CPU
二、多线程：之间争用资源，多线程之间同步与互斥<br>
1,多线程之间的互斥（加锁实现）：同一时间，只能有一个线程访问临界区（防止线程之间争用条件造成的“能量损失”）[对该临界资源进行加锁，表示现在只能由该线程进行访问]<br>
2,多线程之间的同步（线程的等待和唤醒：wait()+notifyAll()）：通信机制；一个线程完成，以某种方式通知其他线程可以访问临界区<br>
3,锁：private final Object lockObj=new Object();
三、重要的话
线程之间的互斥：通过加锁实现：线程访问临界区的代码放在一个代码块中，加锁实现
线程之间的同步：通过wait（）+notify（）的通信机制来实现
wait()和notifyAll()是在线程同步的时候使用的一对方法

lockObj.notifyAll()会唤醒所有在lockObj对象上等待的线程(例如线程执行wait()),唤醒后的线程会在此竞争锁对象 竞争成功后从上次wait()时往后执行.

线程的wait()方法会释放synchronize的lockObj锁,以便其他线程获取锁执行代码

synchronized关键字 保证互斥，wait阻挡继续竞争。noticeAll同步

@Java线程——线程交互——互斥与同步
一、互斥
    同一时间，只能有一个线程访问数据
二、同步
    一种通信机制，一个线程操作完成后，以某种方式通知其他线程
三、实现方法
    1、【互斥】构建锁对象（Object objLock)，通过synchronized(lockObj){  互斥的代码块  }
    2、加锁操作会开销系统资源，降低效率
    3、在某线程的条件不满足任务时，使用lockObj.wait()对线程进行阻挡，防止其继续竞争CPU资源，滞留在wait set中，等待唤醒,【唤醒后继续完成业务】
    4、【同步】在某一代码正确执行完业务后，通过lockObj.notifyAll()唤醒所有在lockObj对象等待的线程

wait方法是暂停当前线程，如果唤醒过后，会是继续执行后面代码，还是直接重新开始方法？

锁池和等待池。

synchronized是锁池，wait、notify、notifyAll是等待池。

等待池的对象是不会竞争锁的，当notifyAll后，等待池中的线程会被唤醒进入到该线程的锁池中重新竞争对象锁，重新获得锁后的对象会从wait后继续执行代码，其他对象会被阻塞，而不是wait。被阻塞的对象会等待下一次被唤醒（notify、notifyAll）。另外，notify不是线程安全的，notifyAll才是。

互斥:同一时间段只有一个线程能运行

同步:一个线程做了某件事，会通知其他线程我做完了

while循环（条件），保证了条件不满足时，当前线程不会去抢占CPU资源

一、线程的特点：
进程是资源分配的最小单位，一个进程中有1—n个线程，线程共享资源，同一时刻只能有一个线程占领CPU
二、多线程：之间争用资源，多线程之间同步与互斥<br>
1,多线程之间的互斥（加锁实现）：同一时间，只能有一个线程访问临界区（防止线程之间争用条件造成的“能量损失”）[对该临界资源进行加锁，表示现在只能由该线程进行访问]<br>
2,多线程之间的同步（线程的等待和唤醒：wait()+notifyAll()）：通信机制；一个线程完成，以某种方式通知其他线程可以访问临界区<br>
3,锁：private final Object lockObj=new Object();
三、重要的话
线程之间的互斥：通过加锁实现：线程访问临界区的代码放在一个代码块中，加锁实现
线程之间的同步：通过wait（）+notify（）的通信机制来实现
wait()和notifyAll()是在线程同步的时候使用的一对方法

一、线程的特点：
进程是资源分配的最小单位，一个进程中有1—n个线程，线程共享资源，同一时刻只能有一个线程占领CPU
二、多线程：之间争用资源，多线程之间同步与互斥<br>
1,多线程之间的互斥（加锁实现）：同一时间，只能有一个线程访问临界区（防止线程之间争用条件造成的“能量损失”）[对该临界资源进行加锁，表示现在只能由该线程进行访问]<br>
2,多线程之间的同步（线程的等待和唤醒：wait()+notifyAll()）：通信机制；一个线程完成，以某种方式通知其他线程可以访问临界区<br>
3,锁：private final Object lockObj=new Object();
三、重要的话
线程之间的互斥：通过加锁实现：线程访问临界区的代码放在一个代码块中，加锁实现
线程之间的同步：通过wait（）+notify（）的通信机制来实现
wait()和notifyAll()是在线程同步的时候使用的一对方法