关闭

线程并发一:概念理解

标签: 线程并发异步多线程
57人阅读 评论(0) 收藏 举报
分类:

1.同步(Synchronous) 和异步(Asynchronous)

同步和异步通常来形容一次方法的调用,同步方法调用一旦开始,调用者必须等到方法调用结束才成继续后续的行为。异步方法调用更像一个消息传递,一旦开始,方法调用就会立即返回调用者可以继续后续的操作。如果异步调用需要返回结果,那么当这个异步调用真实完成时,则会通知调用者。

2.临界区
临界区一般用来表示多线程的共享资源数据。也就是并发情况下要保护的对象。

3.阻塞(Blocking)和非阻塞(Non-Blocking)
阻塞和非阻塞一般用来多线程之间的相互影响或对IO的操作。当一个线程占用了临界区的资源,其他线程线程在调用临界区资源的时候必须等待,等待会导致线程挂起,这种情况就是阻塞。如果当前线程不释放临界区资源,那么其他所用线程都将不能工作
非阻塞:强调没用一个线程可以妨碍其他线程执行,所用线程都会不断尝试获取临界区资源,获取不到直接返回,下次再获取。

4. 死锁(Deadlock)、饥饿(Starvation)、活锁(Livelock)
几种状态都属于多线程活跃性的问题,当出现这种问题的时候,也就表明相关线程出现了问题,很难再执行下去

死锁:是最糟糕的一个问题,是指两个或两个以上的进程(线程)在执行过程中,因争夺资源而造成的一种互相等待的现象,若无外部处理作用,它们都将无限等待下去。

死锁形成条件:
互斥条件:所谓互斥就是进程在某一时间内独占资源。
请求与保持条件:一个进程因请求资源而阻塞时,对已获得的资源保持不放。
不剥夺条件:进程已获得资源,在末使用完之前,不能强行剥夺。
循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系

死锁形成的常见情况有以下几种:

a.忘记释放锁

b.单线程重复申请锁

void sub_func()
{
    EnterCriticalSection();
    do_something();
    LeaveCriticalSection();
}
​
void data_process()
{
    EnterCriticalSection();
    sub_func();
    LeaveCriticalSection();
}

c.多线程多锁申请

void data_process1()
{
    EnterCriticalSection(&cs1);  // 申请锁的顺序有依赖
    EnterCriticalSection(&cs2);
    do_something1();
    LeaveCriticalSection(&cs2);
    LeaveCriticalSection(&cs1);
}
​
void data_process2()
{
    EnterCriticalSection(&cs2);  // 申请锁的顺序有依赖
    EnterCriticalSection(&cs1);
    do_something2();
    LeaveCriticalSection(&cs1);
    LeaveCriticalSection(&cs2);
}

d.环形锁申请
/* 多个线程申请锁的顺序形成相互依赖的环形:
* A - B
* | |
* C - D
*/

饥饿:是指线程因种种原因无法获取所需要的资源导致一直无法执行。
一般会出现饥饿状态有两种原因:
a.某一线程一直占用资源
b.线程优先级问题

活锁:是指线程1可以使用资源,但它很礼貌,让其他线程先使用资源,线程2也可以使用资源,但它很绅士,也让其他线程先使用资源。这样你让我,我让你,那么就会出现资源不断在两个线程中跳动,而没有一个线程可以同时拿到所用资源而正常执行

5.线程优先级
Java中线程可以有自己的优先级,优先级高的线程在竞争资源时会更有优势,但如果无法精准控制多线程的优先级,会导致低优先级的线程可能一直抢占不到资源,从而始终无法运行。所以设置线程优先级要谨慎。在Java中,使用1 到10 表示线程优先级。一般可以使用Thread 类中内置的三个静态标量表示:

    /**
     * The minimum priority that a thread can have.
     */
    public final static int MIN_PRIORITY = 1;

   /**
     * The default priority that is assigned to a thread.
     */
    public final static int NORM_PRIORITY = 5;

    /**
     * The maximum priority that a thread can have.
     */
    public final static int MAX_PRIORITY = 10;

执行下面的示例,可以看到高优先级的线程在大部分情况下都会先执行完任务。

public class PriorityDemo {

    public static class HightThread extends Thread {
        static int count = 0;
        public void run(){
            while (true){
                synchronized (PriorityDemo.class){
                    count ++;
                    if(count > 1000000){
                        System.out.println("HightThread is complete!");
                        break;
                    }
                }
            }
        }
    }

    public static class LowThread extends Thread {
        static int count = 0;
        public void run(){
            while (true){
                synchronized (PriorityDemo.class){
                    count ++;
                    if(count > 1000000){
                        System.out.println("LowThread is complete!");
                        break;
                    }
                }
            }
        }
    }

    public static void main(String[] args){
        Thread high = new HightThread();
        Thread low = new LowThread();

        high.setPriority(Thread.MAX_PRIORITY);
        low.setPriority(Thread.MIN_PRIORITY);
        low.start();
        high.start();
    }
}
0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:324次
    • 积分:61
    • 等级:
    • 排名:千里之外
    • 原创:6篇
    • 转载:0篇
    • 译文:0篇
    • 评论:0条
    文章存档