程序：是为了完成特定任务、用某种语言编写的一组指令的集合。
进程：指的是运行中的程序，进程是程序的一次执行过程，或者正在运行的一个程序。是动态过程有它自身的产生存在和消亡的过程。
线程：线程由进程创建的是进程的一个实体。一个进程可以拥有多个线程。
-
单线程：同一个时刻，只允许执行一个线程
-
多线程：同一个时刻，可以执行多个线程
并发：同一个时刻，多个任务交替执行 单核CPU实现的多任务就是并发。
并行：同一个时刻，多个任务同时执行。多核CPU可以实现并行。
进程和线程的区别
- 进程是操作系统分配的基本单元，而线程是CPU的基本调度单位
- 一个程序运行后至少有一个进程；
- 一个进程可以包含多个线程，但是至少需要一个线程。
- 进程间不能共享数据段地址，但同进程的线程之间可以。
—————————————————————————————————
创建线程的主要方式
- 继承Thread类
- 新增一个类继承Thread类重写Thread类中的run方法，然后创建该对象，并调用该对象的start方法启动一个新线程
- 调用线程对象的start方法才能真正开启一个子线程start内部会自动调用run方法作为子任务的执行内容
- 不能手动直接调用run方法，如果单独的调用了run方法则不会与main主线程抢夺资源，会按照之前的逻辑顺序一步步的执行
- 实现Runnable的接口（一个任务Task),传入Thread对象并执行。
区别：实现Runnable接口方式更适合多个线程共享一个资源的情况，并且避免了单继承的现在，建议使用Runnable；
—————————————————————————————————
线程常用方法
- setName ：设置线程名称，使之与参数name相同
- getName:返回该线程的名称
- start：使该线程开始执行，Java虚拟机底层调用该线程的start（）方法
- run：调用线程对象的run方法
- setPriority:更改线程的优先级
- getPriority:获取线程的优先级
- sleep：在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），线程中的静态方法，使当前线程休眠
- interrupt：中断线程，并没有真正结束线程，一般用于中断正在休眠线程
- yield：线程的礼让，让出CPU让其他的线程执行但礼让的时间不确定，所以也不一定礼让成功
- join：线程的插队，插队的线程一旦插队成功，则肯定先执行完插入的线程的所有任务
—————————————————————————————————
线程优先级（setPriority）
-
通过线程对象的setPriority（priority）方法能够给当前线程对象设置线程优先级
-
每个线程都有一个优先级，高优先级的线程优先与低优先级线程
-
线程优先级越高，不见得就一定会优先执行完成，只能说优先执行的几率更高一些
-
该方法一定要设置在线程的start（）之前否则无效
-
优先级的值有三个常量（MAX_PRIORITY = 10, NORM_PRIORITY = 5, MIN_PRIORITY=1）十个值（1-10）如果超过这个值则会抛出IllegaArgumentException
public class TestThread02 extends Thread{
public static void main(String[] args) {
TestThread02 tt = new TestThread02();
tt.setPriority(8);
tt.start();
TestThread02 tt2 = new TestThread02();
tt2.setPriority(1);
tt2.start();
for (int i = 0; i < 500; i++) {
System.out.println("this is main " + i);
}
}
@Override
public void run() {
for (int i = 0; i < 500; i++) {
// Thread.currentThread()
System.out.println("this is run " + Thread.currentThread().getName() + " " + i);
}
}
}
—————————————————————————————————
用户线程和守护线程
- 用户线程：也叫工作线程，当线程的任务执行完或通知方式结束
- 守护线程：一般是为工作线程服务的，当所有的用户线程结束守护线程自动结束
- 常见的守护线程：垃圾回收机制
守护线程
- 通过线程对象的setDaemon（demon）方法将当前线程设置为一个守护或者非守护线程，demon是一个逻辑值
- 如果daemon是true设置当前线程为一个守护线程，如果daemon是false则设置当前线程为一个非守护级线程
- 如果一个线程被设置为了守护线程，则被守护的线程结束后守护线程可以不必执行完成而提前中断执行，从而提高程序的执行效率
- 也可能存在线程被设置成守护线程，则被守护的线程执行完成后，守护线程也执行完成
- 该方法也应该写在线程对象的start（）方法之前，否则无效
- 可以通过线程对象的isDaemon()方法来判断当前线程是否是一个守护线程
public class TestThread03 extends Thread{
public static void main(String[] args) {
TestThread03 tt = new TestThread03();
tt.setDaemon(true);
tt.start();
System.out.println(tt.isDaemon());
for (int i = 0; i < 500; i++) {
System.out.println("this is main " + i);
}
}
@Override
public void run() {
for (int i = 0; i < 500; i++) {
System.out.println("this is run " + Thread.currentThread().getName() + " " + i);
}
}
}
—————————————————————————————————
线程的同步（synchronized）
线程同步机制
-
在多线程编程，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任何同一时刻，最多有一个线程访问，以保证数据的完整性。
理解：线程同步，即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作，其他线程才能对该内存地址进行操作。
同步具体方法
- 同步代码块
synchronized(对象){//得到对象的锁,才能操作同步代码
//需要被同步代码;
}
-
- 每个对象都有一个互斥锁标记，用来分配给线程的。
- 只有拥有对象互斥锁标记的线程，才能进入对该对象加锁的同步代码块。
- 线程退出同步代码块时，会释放相应的互斥锁标记。
-
同步方法
public synchronized void m (String name){ //需要被同步的代码 }
同步规则
- 只有在调用包含同步代码块的方法，或者同步方法时，才需要对象的锁标记。
- 如调用不包含同步代码块的方法，或普通方法时，则不需要锁标记，可直接调用。
已知JDK中线程安全的类
- StringBuffer
- Vector
- Hashtable
以上类中的公开方法，均为synchronized修饰的同步方法
———————————————————————————————————————
线程同步应用—互斥锁
- Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。
- 每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。
- 关键字synchronized来与对象的互斥锁联系。当某个对象用synchronized修饰时,表明该对象在任一时刻只能由一个线程访问
- 同步的局限性:导致程序的执行效率要降低
- 同步方法(非静态的)的锁可以是this,也可以是其他对象(要求是同一个对象)
- 同步方法(静态的)的锁为当前类本身。
public synchronized static void m1() {
}
public static void m2() {
synchronized (SellTicket.class) {
System.out.println("m2");
}
}
注意事项
- 同步方法如果没有使用static修饰:默认锁对象为this
- 如果方法使用static修饰,默认锁对象:当前类.class
- 实现的落地步骤:
- 需要先分析上锁的代码选择同步代码块或同步方法
- 要求多个线程的锁对象为同一个即可!
多线程火车票售卖问题
编程模拟三个售票口售票100分别使用继承Thread和实现Runnable创建线程进行售票，并分析有什么问题？
//继承Thread方式实现
public class ThreadTicket01 extends Thread{
public static int count = 100;
public static void main(String[] args) {
ThreadTicket01 t1 = new ThreadTicket01();
ThreadTicket01 t2 = new ThreadTicket01();
ThreadTicket01 t3 = new ThreadTicket01();
t1.start();
t2.start();
t3.start();
}
private static int ticketNum = 100;//让多个线程共享 ticketNum
@Override
public void run() {
while (true) {
if (ticketNum <= 0) {
System.out.println("售票结束...");
break;
}
//休眠 50 毫秒, 模拟
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
+ " 剩余票数=" + (--ticketNum));
}
}
}
//实现Runnable接口方式实现
public class RunnableTest01 implements Runnable{
public static int count = 100;
public static void main(String[] args) {
RunnableTest01 tt1 = new RunnableTest01();
new Thread(tt1).start();
new Thread(tt1).start();
new Thread(tt1).start();
}
private static int ticketNum = 100;//让多个线程共享 ticketNum
@Override
public void run() {
while (true) {
if (ticketNum <= 0) {
System.out.println("售票结束...");
break;
}
//休眠 50 毫秒, 模拟
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
+ " 剩余票数=" + (--ticketNum));//1 - 0 - -1 - -2
}
}
}
问题：发现会出现超买或重复卖的情况
//使用互斥锁解决
public class SellTicket implements Runnable{
public static void main(String[] args) {
SellTicket sellTicket = new SellTicket();
new Thread(sellTicket).start();//第一个窗口
new Thread(sellTicket).start();//第二个窗口
new Thread(sellTicket).start();//第三个窗口
}
private int ticketNum = 100;
private boolean loop = true;
Object object = new Object();
public /*synchronized*/ void sell() {
//同步方法, 在同一时刻， 只能有一个线程来执行 sell 方法
synchronized (/*this*/ object) {
if (ticketNum <= 0) {
System.out.println("售票结束...");
loop = false;
return;
}
//休眠 50 毫秒, 模拟
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
+ " 剩余票数=" + (--ticketNum));//1 - 0 - -1 - -2
}
}
@Override
public void run() {
while (loop){
sell();
}
}
}
———————————————————————————————————————
经典问题
线程的死锁:
当第一个线程拥有A对象锁标记，并等待B对象锁标记，同时第二个线程拥有B对象锁标记，并等待A对象锁标记时，产生死锁。
一个线程可以同时拥有多个对象的锁标记，当线程阻塞时，不会释放已经拥有的锁标记，由此可能造成死锁。
理解：多个线程都占用了对方的锁资源，但不肯相让，导致了死锁,在编程时一定要避免死锁的发生.
应用案例：
妈妈：你先完成作业，才让你玩手机
小明：你先让我玩手机，我再完成作业
/**
* 模拟线程死锁
*/
public class DeadLock_ {
public static void main(String[] args) {
//模拟死锁现象
DeadLockDemo A = new DeadLockDemo(true);
A.setName("A 线程");
DeadLockDemo B = new DeadLockDemo(false);
B.setName("B 线程");
A.start();
B.start();
}
}
//线程
class DeadLockDemo extends Thread {
static Object o1 = new Object();// 保证多线程，共享一个对象,这里使用 static
static Object o2 = new Object();
boolean flag;
public DeadLockDemo(boolean flag) {//构造器
this.flag = flag;
}
@Override
public void run() {
//下面业务逻辑的分析
//1. 如果 flag 为 T, 线程 A 就会先得到/持有 o1 对象锁, 然后尝试去获取 o2 对象锁
//2. 如果线程 A 得不到 o2 对象锁，就会 Blocked
//3. 如果 flag 为 F, 线程 B 就会先得到/持有 o2 对象锁, 然后尝试去获取 o1 对象锁
//4. 如果线程 B 得不到 o1 对象锁，就会 Blocked
if (flag) {
synchronized (o1) {//对象互斥锁, 下面就是同步代码
System.out.println(Thread.currentThread().getName() + " 进入 1");
synchronized (o2) { // 这里获得 li 对象的监视权
System.out.println(Thread.currentThread().getName() + " 进入 2");
}
}
} else {
synchronized (o2) {
System.out.println(Thread.currentThread().getName() + " 进入 3");
synchronized (o1) { // 这里获得 li 对象的监视权
System.out.println(Thread.currentThread().getName() + " 进入 4");
}
}
}
}
}
释放锁
- 释放锁的情况
- 当前线程的同步方法、同步代码块执行结束
- 当前线程在同步代码块，同步方法中遇到break、return
- 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束
- 当前线程在同步代码块、同步方法中执行了线程对象的wait（）方法，当前线程暂停，并释放锁。
- 不释放锁的情况
- 线程执行同步代码块或者同步方法时，程序调用Thread.sleep() Thread.yield()方法暂停当前线程的执行，不会释放锁。
- 线程执行同步代码块时，其他线程调用了该线程的suspend（）方法将该线程挂起，该线程不会释放锁。（应尽量避免使用suspend()和resume（）方法来控制线程）
单例设计模式
双重检测来保证大访问量下也能实现单例模式
可能会出现的问题是：
- 第一个线程对象进入当前方法的时候，发现instance为空，而第二个线程也在瞬间进入该方法，发现instance也为空。
- 那么以synchronized同步代码块的方式，来进行对象的创建,即使第二个对象发现当前instance为空，也只能等待第一个线程对象把同步代码块执行完成才能进入执行。
- 当第一个线程对象执行完成后，instance对象已经被创建好，不为空了，并且是释放了线程锁,第二个线程对象再进入同步代码块，再次进行instance的判空操作，发现instance已经不为空，因此就可以保证单例的最终实现。
/**
*
*
* 单例设计模式：在整个程序运行过程中，某一个类型的对象实例有的话，最多只有一个实例
*
* 步骤：
* 1. 构造器私有化
* 2. 在当前类中提供公有的、静态的、返回值为当前类本身的一个方法
*/
public class SingleTon {
private static SingleTon instance = null;
private static Object lock = new Object();
private SingleTon(){
}
public static SingleTon getInstance(){
if(instance == null){
synchronized (lock){
if(instance == null){
instance = new SingleTon();
}
}
}
return instance;
}
}
//测试类
public class TestSingleTon {
public static void main(String[] args) {
//SingleTon st = new SingleTon();
SingleTon st01 = SingleTon.getInstance();
SingleTon st02 = SingleTon.getInstance();
System.out.println(st01 == st02);
}
}
生产者和消费者模式
生产者、消费者:
若干个生产者在生产产品，这些产品将提供给若干个消费者去消费，为了使生产者和消费者能并发执行，在两者之间设置一个能存储多个产品的缓冲区，生产者将生产的产品放入缓冲区中，消费者从缓冲区中取走产品进行消费，显然生产者和消费者之间必须保持同步，即不允许消费者到一个空的缓冲区中取产品，也不允许生产者向一个满的缓冲区中放入产品。
//面包工厂类
public class BreadContainer {
private int currentNum; // 面包工厂的当前面包数量
private static int MAX_NUM = 500; // 仓库的最大容量
public void setCurrentNum(int currentNum) {
this.currentNum = currentNum;
}
/**
* 生产方法,要生产指定num箱面包,
* 如果当前面包数量+要生产的数量超过了当前仓库的容量,则暂停生产
* @param num, 要生产的数量
*/
public synchronized void produce(int num){
System.out.printf("尝试生产%d箱面包\n", num);
try {
while(currentNum + num > MAX_NUM){
System.out.println("容量不足，暂停生产...");
wait();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
currentNum += num;
System.out.printf("成功生产了%d箱面包，当前的库存为%d\n", num, currentNum);
// 唤醒线程队列中随机的某个线程来进行执行
notify();
// 唤醒线程队列中的所有线程
//notifyAll();
}
/**
* 消费方法
* 要消费的数量于库存的容量，则暂停消费
* @param num
*/
public synchronized void consume(int num){
System.out.printf("尝试消费%d箱面包\n", num);
try {
while (num > currentNum){
System.out.println("面包不足，暂停消费...");
wait();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
currentNum -= num;
System.out.printf("成功消费了%d箱面包，当前的库存是%d\n", num, currentNum);
// 唤醒线程队列中随机的某个线程来进行执行
notify();
// 唤醒线程队列中的所有线程
//notifyAll();
}
}
//消费者类
public class Consumer extends Thread{
private int num;
private BreadContainer bc;
public Consumer(BreadContainer bc, int num){
this.num = num;
this.bc = bc;
}
/**
* 消费者的消费方法
* 使用面包工厂的消费方法来消费num箱面包
*/
@Override
public void run() {
bc.consume(num);
}
}
//生产者类
public class Producer extends Thread{
private int num;
private BreadContainer bc;
public Producer(BreadContainer bc, int num){
this.num = num;
this.bc = bc;
}
/**
* 生产者的生产方法
* 使用面包工厂的生产方法来生产num箱面包
*/
@Override
public void run() {
bc.produce(num);
}
}
//测试类
public class TestProCon {
public static void main(String[] args) {
BreadContainer bc = new BreadContainer();
bc.setCurrentNum(40);
Producer p1 = new Producer(bc, 50);
Producer p2 = new Producer(bc, 30);
Producer p3 = new Producer(bc, 70);
Producer p4 = new Producer(bc, 40);
Consumer c1 = new Consumer(bc, 40);
Consumer c2 = new Consumer(bc, 50);
Consumer c3 = new Consumer(bc, 60);
Consumer c4 = new Consumer(bc, 70);
p1.start();
p2.start();
p3.start();
p4.start();
c1.start();
c2.start();
c3.start();
c4.start();
}
}
———————————————————————————————————————
线程通信
等待:
-
public final void wait()
-
public final void wait(long timeout)
-
必须在对obj加锁的同步代码块中。在一个线程中，调用obj.wait()时，此线程会释放其拥有的所有锁标记。同时此线程阻塞在o的等待队列中。释放锁，进入等待队列
通知:
-
public final void notify（)
-
public final void notifyAll()
-
必须在对obj加锁的同步代码块中。从obj的Waiting中释放一个或全部线程。对自身没有任何影响。
面试题
wait和sleep的区别
（1）sleep()不释放锁，wait()释放锁，使得其他线程可以使用同步控制块或者方法。
（2）sleep()在Thread类中声明的，wait()在Object类中声明
（3）sleep()是静态方法，是Thread.sleep()，wait()是非静态方法，必须由“同步锁”对象调用
（4）sleep()方法导致当前线程进入阻塞状态后，当时间到或interrupt()醒来，wait()方法导致当前线程进入阻塞状态后，由notify或notifyAll()
（5）sleep 必须捕获异常，而wait ， notify 和notifyAll 不需要捕获异常
扫一扫
280
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
