https://blog.csdn.net/qq_35733751/article/details/82777127

1. 线程共享资源

  如果说pthread_create函数跟fork函数是对应的，一个创建线程，一个创建进程（实际上fork和pthread_create都是调用的内核函数clone，只是clone的参数不同，fork出来的进程拥有不同的地址空间，而pthread_create创建的线程共享地址空间）。

  但是进程调用fork创建进程的代价较高，调用的过程实际上非常复杂，即便是依靠写时复制机制，仍然需要复制诸如内存页表和文件描述符表之类的多种进程属性，这意味着fork调用在时间上的开销比pthread_create函数更多（关于fork函数参考：18-用fork函数创建新进程）。

   但线程解决了这个问题，线程之所以能够方便，快速的共享数据，是因为进程调用fork创建子进程所需复制的诸多进程属性在线程间本来就是共享的，无需复制内存页，页表等（因为复制内存页和页表花费的开销不少），这对线程来说，效率提高了不少。当然这是有代价的：不过这要避免出现多个线程同时修改同一份数据的情况，这需要使用线程同步机制（这里暂时不讨论同步问题）。

图1（图片摘自《linux/unix系统编程手册》）

从图1来看，由于同一进程的多个线程共享进程的资源，比如全局内存（数据段和堆），除此之外还共享以下资源和环境：

代码文本段
打开的文件描述符
信号处理函数
当前工作目录
用户id和组id
进程id和父进程id
…

有些资源是每个线程各自独有一份，非共享：

线程id
用户空间栈
errno变量
信号屏蔽字
调度优先级
…

2. 线程共享实验——全局变量

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>

//全局变量
int var = 100;

//线程主控函数
void *tfn(void *arg) {
        
        //修改全局变量var的值
        var = 200;
        printf(" create thread succesful\n");
        return NULL;
}

int main(void) {
        //主控线程第一次打印var
        printf("before pthread_create var = %d\n", var);
        pthread_t tid;
        pthread_create(&tid, NULL, tfn, NULL);
        sleep(1);
        //主控线程再次打印var
        printf("after pthread_create, var = %d\n", var);
        return 0;
}

程序执行结果：

说明线程间是共享全局变量的

3. 线程共享实验——局部变量

既然全局变量是共享的，那么局部变量是不是也是共享的呢？为了验证这个问题，我们来看实验二

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>

//线程主控函数
void *tfn(void *arg) {
        int i = (int)arg;
        //局部变量
        int temp_val = 250;
        if(i == 0){
                //线程1修改了temp_val后，打印temp_val的值
                temp_val = 100;
                printf("pthread1 , temp_val = %d\n" , temp_val);
        }else{
                //线程2打印temp_val的值
                printf("pthread2 , temp_val = %d\n" , temp_val);
        }
        printf(" create thread succesful\n");
        return NULL;
}

int main(void) {
        pthread_t tid[2];
        int i;
        for(i = 0; i < 2; i++){
                pthread_create(&tid[i] , NULL , tfn , (void *)i);
        }
        sleep(1);
        return 0;
}

程序执行结果：

  局部变量temp_val的初始值是250，在创建了2个线程，线程1修改了temp_val的值为100并打印，而线程2再访问temp_val的值还是250，这说明线程间是不共享局部变量的（有趣的是可以通过指针直接访问另个一个线程的局部变量，这也不奇怪，图1可知多个线程虽然都有自己的栈区域，但总体上都是在进程的栈中）。

  问题来了，为什么线程间不共享局部变量，为了弄明白这个问题，我们还得回到图1。

图2

  首先，线程的生命周期一般是在线程主函数中，当线程一创建就会在用户栈开辟一块空间给线程主函数使用，这意味着我们每创建一个线程都会在用户栈开辟一块空间给线程主函数使用。如图2所示：线程1修改局部变量temp_val的值为100，实际上修改的是线程1的栈里的temp_val的值，并不会影响线程2的栈中的temp_val，所以线程2打印temp_val的值还是250，也就是说多线程不共享用户栈。

4. 线程和进程的区别

  另外之前在学习进程时，我们的理解是进程就是程序运行的执行体，而实际上进程一旦创建就自动包含了一个主线程，真正的执行体是主线程。

  那么进程是什么？我们可以把进程理解为空间上的概念，它为所有的执行体（线程）提供必要的资源（内存、文件描述符、代码等），而线程，是时间上的概念，它是抽象的、假想的、动态的指令执行过程。

  可以把进程理解为学校或学校的各种资源，线程是学校里的一个个学习的学生，学生共享学校里的各种资源。

  但是以上这些都是概念上的线程和进程的区别，如果我们要真正的本质区分进程和线程，就是看是否共享PCB进程控制块，因为进程间PCB是各自独立的，而线程间PCB是共享的。

  因为线程间是共享全局变量的，这说明了线程间的虚拟地址空间是一样的，pthread_create函数底层也复制了一份一模一样的PCB，所以说一个线程修改了数据空间的数据的话，其他线程都会因此受到影响。
 

多线程中的一个核心问题就是对共享资源的读写问题。你永远都不知道一个线程何时在运行。如果同时有多个线程对一个对象进行读写，结果就会出现脏数据

接下来展示一个多线程同时对一个对象进行读写出现脏数据的案例。

为了方便解耦，创建一个抽象类。

public abstract class Ingenerator  {

    private volatile boolean caceled = false;
    public abstract int next();

    public void cacel(){
        caceled = true;
    }
    public boolean isCanceled(){
        return caceled;
    }

}

EvenChecker任务总是读取和测试从其相关的Ingenerator 返回的值。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class EvenChecker implements Runnable {

    private Ingenerator generator;
    public EvenChecker(Ingenerator g){
        generator = g;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        while(!generator.isCanceled()){
            int val = generator.next();
            if(val%2!=0){
                System.out.println(val + " not even!");
                generator.cacel();
            }
        }

    }

    public static void test(Ingenerator gp,int count){
        System.out.println("Press Control to exit");
        ExecutorService exec = Executors.newCachedThreadPool();
        for(int i = 0;i<count;i++){
            exec.execute(new EvenChecker(gp));
        }
        exec.shutdown();
    }

}

继承Ingenerator抽象类的next()产生偶数。

public class EvenGenerator extends Ingenerator {
    private int currentEvenValue = 0;

    @Override
    public int next() {
        ++currentEvenValue;
        ++currentEvenValue;
        return currentEvenValue;
    }

    public static void main(String[] args) {
        EvenChecker.test(new EvenGenerator(), 10);
    }

}

一个线程有可能在另一个线程执行第一个++currentEvenValuede 操作之后，还没有来得及执行第二个操作之前调用了next()方法。这个时候可能就会产生一个奇数。也就是脏数据。

基本上所有的并发模式在解决线程冲突问题的时候，都是采用序列化访问共享资源的方案。
一个屋子只有一个浴室，多个人（多个线程）都希望能单独使用这个浴室（共享资源）。为了使用浴室，一个人先敲门，看看有没有人，如果没人的话，他就进入浴室并锁上门。等待使用浴室的人们挤在浴室门口，当锁住浴室门的那个人打开锁离开的时候，离门最近的那个人可能进入浴室，可以通过yield()和setPriority()来给线程调度器提供建议，虽然未必有用。还是取决于CPU。

Java提供关键字synchronized的形式，来防止资源冲突。当线程执行被synchronized关键字保护的代码片段时，它将检查锁是否可用，然后获取锁，执行代码，释放锁。

注意，在使用并发的时候，将域(currentEvenValuede)设置为private非常重要，否则，synchronized关键字就不能阻止其它线程之间访问域。
一个线程可以多次获得对象的锁，如果一个方法在同一对象上调用第二个方法，后者又调用同一对象上的另一个方法，就会发生这种情况。JVM负责跟踪对象被加锁的次数。如果一个对象被解锁（即锁被完全释放），其计数变为0。在线程第一次给对象加锁的时候，计数变为1.每当这个相同的线程在这个对象获得锁时，计数都会递增。显然，只有首先获得了锁的线程才能允许继续获取多个锁。每当任务离开一个synchronized方法，计数递减，当计数为0时，锁被完全释放。

针对每个类，也有一个锁，所以synchronized static方法可以在类的范围内防止对static数据的并发访问。
如果在你的类中有超过一个方法在处理共享资源，那么你必须同步所有相关的方法。

使用显式的Lock对象

Lock对象必须被显式的创建，锁定和释放。

当你使用synchronized关键字的时候，需要写的代码量更少，并且用户错误出现的可能性也会降低，因此通常只有在解决特殊问题时，才使用显式的Lock对象。例如，用synchronized关键字不能尝试获取锁且最终获取锁会失败，或者尝试着获取锁一段时间，然后放弃它。

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;


public class AttemptLocking {

    private ReentrantLock lock = new ReentrantLock();

    public void untimed(){

        boolean captured = lock.tryLock();
        try {
            System.out.println("tryLock(): "+captured);
        } finally{
            if(captured)lock.unlock();
        }

    }

    public void timed(){

        boolean captured = false;
        try {
            captured = lock.tryLock(2, TimeUnit.SECONDS);
        } catch (Exception e) {
            throw new RuntimeException();
        }

        try {
            System.out.println("tryLock(2, TimeUnit.SECONDS):" + captured);
        } finally{
            if(captured)lock.unlock();
        }

    }

    public static void main(String[] args) {
        final AttemptLocking al = new AttemptLocking();
        al.untimed();
        al.timed();

        new Thread(){
            {setDaemon(true);}
            public void run() {
                al.lock.lock();
                System.out.println("acquired");
            };
        }.start();

        //通过yield()来使的后台线程和al.untimed()对al这个资源进行竞争，如果后台线程先获取到资源则把资源锁定了。
        Thread.yield();
        al.untimed();
        al.timed();

    }

}

ReentrantLock允许你尝试着获取锁，如果获取失败，那你可以决定离开去执行其它事情，而不用一直等待这个锁被释放，就像在untimed()方法中所看到的。在timed()中，做出了尝试去获取锁，该尝试可以在2秒之后失败。