1.并发访问（同一个时间段内执行）<====>并行（同时刻）
2.Thread.sleep(1000);//当前线程睡1秒（1000毫秒）当前线程休息，其他线程先占用资源
3.子类覆盖父类方法 子类不能抛出新的异常 只能使用Try-cache方法
4.synchronized 不能修饰 run方法 因为修饰过之后 就执行完了
线程安全 1.synchronized 2.线程锁 lock
实例：1.synchronized 也可以作为一个修饰符放在类或者方法前面 但是 要做到 范围尽可能的小 所以用下面的代码块
synchronized（）{
/*要执要执行的资源*/
}
2.synchronized
package xiancheng;
/*解决方法
* 1.同步代码块
* 2.同步方法
* 3.锁机制【同步锁：同步监听对象，互斥锁，同步监听锁】
*/
class Chi implements Runnable{
public static int num=100;
public void run() {
for (int i = 0; i < 100; i++) {
synchronized(this){//小括号内可以放Chi.class【我也不知道为什么】
try {
Thread.sleep(20);
} catch (InterruptedException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
if(num>0) {
System.out.println(Thread.currentThread().getName()+"吃了第"+num--+"个苹果");
}
}
}
}
}
public class Youxi {
public static void main(String[] args) {
Chi a = new Chi();
new Thread(a,"小A").start();
new Thread(a,"小B").start();
new Thread(a,"小C").start();
}
}
2. lock====>创建对象 获取锁 释放锁 try-catch-finally 【父类中没有抛出错误子类中就不能抛出错误 只能使用try catch】
package xiancheng;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/*解决方法
* 1.同步代码块
* 2.同步方法
* 3.锁机制【同步锁：同步监听对象，互斥锁，同步监听锁】
*/
class Chi implements Runnable{
public static int num=100;
private final Lock lock = new ReentrantLock();
public void run() {
for (int i = 0; i < 100; i++) {
lock.lock();
try {
Thread.sleep(20);
if(num>0) {
System.out.println(Thread.currentThread().getName()+"吃了第"+num--+"个苹果");
}
} catch (InterruptedException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
finally {
lock.unlock();
}
}
}
}
public class Youxi {
public static void main(String[] args) {
Chi a = new Chi();
new Thread(a,"小A").start();
new Thread(a,"小B").start();
new Thread(a,"小C").start();
}
}
