- 原子性：要么全部完成，要么全部失败
- 可序性：程序线程有序的进行（通过锁）
- 可见性：修改的过程能够看见
并发编程的本质：充分利用CPU的资源
进程与线程的区别
进程是资源分配的基本单位，例如qq这些就是进程
线程是任务调度的基本单位，进程包含多个线程
java中默认有两个线程 main gc
1.1 多线程回顾-
Thread 和Runnable（常用）
//MyTread package com.thread; public class MyThread01 extends Thread{ @Override public void run() { System.out.println("i start"); } } ///test public class ThreadDemo01 { public static void main(String[] args) { Thread t1 = new MyThread01(); t1.start(); } } //runnable public class Runable1 implements Runnable{ @Override public void run() { System.out.println("我开始了"); } } //test public class RunTest { public static void main(String[] args) { new Thread(new Runable1()).start(); } }
- 守护线程：在start之前使用setDaemon方法将线程设置为守护线程，守护线程需等其他非守护线程执行完毕之后才能执行
- 非守护线程：我们平时用的线程默认为非守护线程
原因：直接调用run方法就是把run当做是普通方法调用了，run方法就是一个普通的方法，没有真正的启动一个线程 所以要启动线程需要真正的去掉用start方法
1.4 join方法实用join之后此线程就会优先执行完毕
1.5 线程的状态- new 新生
- 运行 runnable
- 阻塞 bloked
- 超时等待
- 终止
-
wait 是object -->必须在同步代码块中 ，不需要捕获异常，会释放锁
-
sleep 是Thread---->不会释放锁，需要捕获异常
加载实例方法是加在对象上面的 ，加在静态方法上就是加在.class文件上
2.2 锁的本质共享资源后多个线程操作会造成一些问题 ，我们通过锁就可以保证同一时间只能有一个线程访问资源
2.3 lock锁(**)传统Synchronized 本质：进行排队，对象拿锁用完就释放锁
lock 接口普通实现类 ReentranLock
公平锁：可以先来先到
非公平锁：可以插队(默认)
lock.lock();//加锁
try{
业务代码；
}catch{
}
finally{
lock.unlock();//解锁
}
Synchronized与lock的区别
- Synchronized是java关键字，lock是一个java类
- Synchronized 无法判断锁的状态，lock可以判断锁的状态
- Synchronized会自动释放锁，lock必须手动释放锁不释放锁会产生死锁
- Syn线程1阻塞线程二会等，lock锁不会等
- syn可重入锁，不可以中断非公平，lock，可重锁
- syn适合少量的代码，lock适合大量的代码
如果没有产品就通知生产者生产
口诀：判断等待，业务，通知
public class Customer implements Runnable{
private Box b;
public Customer(Box b) {
this.b = b;
}
@Override
public void run() {
while (true) {
b.get();
}
}
}
public class producer implements Runnable {
private Box b;
public producer(Box b) {
this.b = b;
}
@Override
public void run() {
for (int i = 5; i > 0; i--) {
b.put(i);
}
}
}
//box
public class Box {
private int milk;
private boolean state = false;
public synchronized void put(int milk){
if (state){
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
this.milk=milk;
System.out.println("送来"+milk+"牛奶");
state = true;
notifyAll();
}
public synchronized void get(){
if (!state){
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("用户拿到了"+this.milk+"奶");
state=false;
notifyAll();
}
}
//test
public class ThreadDemo {
public static void main(String[] args) {
Box b = new Box();
producer p =new producer(b);
Customer c = new Customer(b);
Thread t1 = new Thread(p);
Thread t2 = new Thread(c);
t1.start();
t2.start();
}
}
public class PcTestDemo {
public static void main(String[] args) {
Pcdemo pc = new Pcdemo();
new Thread(()->{
try {
for (int i = 0; i < 10; i++) {
pc.add();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
},"A").start();
new Thread(()->{
try {
for (int i = 0; i < 10; i++) {
pc.denumber();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
},"B").start();
}
}
class Pcdemo{
private int number=0;
public synchronized void add() throws InterruptedException {
//判断是否需要等待
while (number!=0){
this.wait();
}
number++;
System.out.println(Thread.currentThread().getName()+"第"+number);
//唤醒其他线程
this.notifyAll();
}
public synchronized void denumber() throws InterruptedException {
while (number!=1){
this.wait();
}
number--;
System.out.println(Thread.currentThread().getName()+number);
this.notifyAll();
}
}
*** 注意使用if判断会产生虚假唤醒
所以判断是采用while循环来判断
