最近，我在一次采访中被问到一个问题:进程和线程有什么区别?真的，我不知道答案。我想了一会儿，给出了一个非常奇怪的答案。

线程共享相同的内存，而进程不共享。回答完这个问题后，面试官对我邪恶地笑了笑，然后接连问了我几个问题:

问:你知道节目分成哪些部分吗?

我的答案是:是的(认为这很简单)堆栈，数据，代码，堆

问:那么，告诉我:线程共享哪些片段?

我无法回答这个问题，最后只能把它们都说了出来。

请问，谁能就进程和线程之间的区别给出正确的、令人印象深刻的答案?

这是一个深思熟虑的设计决定，还是我们当前浏览器的一个问题，这个问题将在未来的版本中得到纠正?

有人能告诉我如何将参数传递给线程吗?

另外，匿名类是如何工作的?

我一直试图找到一个好的定义，并理解线程到底是什么。

似乎我一定遗漏了一些明显的东西，但每次我读到什么是线程，它几乎是一个循环的定义，比如“线程是执行的线程”或“一种划分运行任务的方法”。嗯嗯。嗯?

It seems from what I have read that a thread is not really something concrete, like a process is. It is in fact just a concept. From what I understand of the way this works, a processor executes some commands for a program (which has been termed a thread of execution), then when it needs to switch to processing for some other program for a bit, it stores the state of the program it's currently executing for somewhere (Thread Local Storage) and then starts executing the other program's instructions. And back and forth. Such that, a thread is really just a concept for "one of the paths of execution" of a program that is currently running.

不像一个过程，它是一个资源的集合，等等。

作为一个定义的例子，它并没有真正帮助到我…

从维基百科:

“在计算机科学中，线程是执行线程的缩写。线程是程序将自身分割(称为“分裂”)为两个或多个同时(或伪同时)运行的任务的一种方法。不同操作系统的线程和进程各不相同，但一般来说，线程包含在进程中，同一进程中的不同线程共享相同的资源，而同一多任务操作系统中的不同进程则不相同。”

我说的对吗?错了吗?线程到底是什么?

编辑:显然，线程也有自己的调用堆栈，所以这是一个具体的东西。

原子/挥发/同步内部是如何工作的?

下面的代码块有什么区别?

代码1

private int counter;

public int getNextUniqueIndex() {
    return counter++; 
}

代码2

private AtomicInteger counter;

public int getNextUniqueIndex() {
    return counter.getAndIncrement();
}

代码3

private volatile int counter;

public int getNextUniqueIndex() {
    return counter++; 
}

---

挥发物以以下方式工作吗?是

volatile int i = 0;
void incIBy5() {
    i += 5;
}

相当于

Integer i = 5;
void incIBy5() {
    int temp;
    synchronized(i) { temp = i }
    synchronized(i) { i = temp + 5 }
}

我认为两个线程不能同时进入同步块…我说的对吗?如果这是真的，那么如何atomic.incrementAndGet()工作没有同步?它是否线程安全?

内部读取和写入volatile变量/原子变量之间的区别是什么?我在一些文章中读到，线程有一个变量的本地副本-那是什么?

c#有它自己版本的java "synchronized"关键字吗?

也就是说，在java中，它可以被指定为一个函数、一个对象或一段代码，如下所示:

public synchronized void doImportantStuff() {
   // dangerous code goes here.
}

or

public void doImportantStuff() {
   // trivial stuff

   synchronized(someLock) {
      // dangerous code goes here.
   }
}

一次又一次，我看到它说使用async-await不会创建任何额外的线程。这是没有道理的，因为计算机一次可以做多件事的唯一方法是

实际上同时做多件事(并行执行，使用多个处理器) 通过调度任务并在它们之间切换来模拟它(做一点a，一点B，一点a，等等)。

因此，如果async-await都不做这些，那么它如何使应用程序具有响应性呢?如果只有1个线程，那么调用任何方法都意味着在执行其他操作之前等待该方法完成，并且该方法中的方法必须在继续执行之前等待结果，以此类推。

有人能很好地解释一下c#中的volatile关键字吗?它能解决哪些问题，不能解决哪些问题?在哪些情况下，它将节省我使用锁定?

例如，在c#中调试线程时，你可以看到每个线程的ID。

我无法找到一种方法以编程方式获得相同的线程。我甚至无法获得当前线程的ID(在thread . currentthread的属性中)。

所以，我想知道Visual Studio如何获得线程的id，是否有一种方法来获得id 2345的线程句柄，例如?

我试图理解什么使得锁在并发如此重要，如果一个人可以使用同步(这)。在下面的虚拟代码中，我可以这样做:

同步整个方法或同步脆弱区域(Synchronized (this){…}) 或者使用ReentrantLock锁定易受攻击的代码区域。

代码:

    private final ReentrantLock lock = new ReentrantLock(); 
    private static List<Integer> ints;

    public Integer getResult(String name) { 
        .
        .
        .
        lock.lock();
        try {
            if (ints.size()==3) {
                ints=null;
                return -9;
            }   

            for (int x=0; x<ints.size(); x++) {
                System.out.println("["+name+"] "+x+"/"+ints.size()+". values >>>>"+ints.get(x));
            }

        } finally {
            lock.unlock();
        } 
        return random;
}