本地线程

　　大家都晓得.NET中线程同步有以下几种方式： 　　临界区（Critical Section）、互斥量（Mutex）、信号量（Semaphore）、事件（Event） 　　1、临界区：通过对多线程的串行化来访问公共资源或一段代码，速度快，适合控制数据访问。在任意时刻只允许一个线程对共享资源进行访问，如果有多个线程试图访问公共资源，那么在有一个线程进入后，其他试图访问公共资源的线程将被挂起，并一直等到进入临界区的线程离开，临界区在被释放后，其他线程才可以抢占。 　　2、互斥量：采用互斥对象机制。 只有拥有互斥对象的线程才有访问公共资源的权限，因为互斥对象只有一个，所以能保证公共资源不会同时被多个线程访问。互斥不仅能实现同一应用程序的公共资源安全共享，还能实现不同应用程序的公共资源安全共享 　　3、信号量：它允许多个线程在同一时刻访问同一资源，但是需要限制在同一时刻访问此资源的最大线程数目 　　4、事 件： 通过通知操作的方式来保持线程的同步，还可以方便实现对多个线程的优先级比较的操作 　　临界区 　　 Interlocked：为多个线程共享的变量提供原子操作 　　此类的方法可以防止可能在下列情况发生的错误：计划程序在某个线程正在更新可由其他线程访问的变量时切换上下文；或者当两个线程在不同的处理器上并发执行时。 此类的成员不引发异常。 那么问题来了，为什么是原子级

一、JDK的组成 JDK： JDK是Java开发工具包，是Sun Microsystems针对Java开发员的产品。JDK中包含JRE（在JDK的安装目录下有一个名为jre的目录，里面有两个文件夹bin和lib，在这里可以认为bin里的就是jvm，lib中则是jvm工作所需要的类库，而jvm和 lib和起来就称为jre）和一堆Java工具（javac/java/jdb等）和Java基础的类库（即Java API 包括rt.jar）。 Java Runtime Environment（JRE）： 是运行基于Java语言编写的程序所不可缺少的运行环境。也是通过它，Java的开发者才得以将自己开发的程序发布到用户手中，让用户使用。JRE中包含了Java virtual machine（JVM），runtime class libraries和Java application launcher，这些是运行Java程序的必要组件。 JVM（java virtual machine）： 就是我们常说的java虚拟机，它是整个java实现跨平台的最核心的部分，所有的java程序会首先被编译为.class的类文件，这种类文件可以在虚拟机上执行。 二、JVM的位置 JVM就是运行在操作系统之上的一个软件 三、JVM体系结构 JVM的组成： 类加载子系统 Class loader 运行时数据区 JVM

1) 什么是线程？ 线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。程序员可以通过它进行多处理器编程，你可以使用多线程对 运算密集型任务提速。比如，如果一个线程完成一个任务要100毫秒，那么用十个线程完成改任务只需10毫秒。Java在语言层面对多线程提供了卓越的支 持，它也是一个很好的卖点。 2) 线程和进程有什么区别？ 线程是进程的子集，一个进程可以有很多线程，每条线程并行执行不同的任务。不同的进程使用不同的内存空间，而所有的线程共享一片相同的内存空间。别把它和栈内存搞混，每个线程都拥有单独的栈内存用来存储本地数据。 3) 如何在Java中实现线程？ 在语言层面有两种方式。java.lang.Thread 类的实例就是一个线程但是它需要调用java.lang.Runnable接口来执行，由于线程类本身就是调用的Runnable接口所以你可以继承 java.lang.Thread 类或者直接调用Runnable接口来重写run()方法实现线程。 4) 用Runnable还是Thread？ 这个问题是上题的后续，大家都知道我们可以通过继承Thread类或者调用Runnable接口来实现线程，问题是，那个方法更好呢？什么情况下使 用它？这个问题很容易回答，如果你知道Java不支持类的多重继承，但允许你调用多个接口。所以如果你要继承其他类

本文主要讲解Java并发相关的内容，包括锁、信号量、堵塞队列、线程池等主要内容。 并发的优点和缺点 在讲述怎么利用多线程的情况下，我们先看一下采用多线程并发的优缺点。 优点 提高资源利用率 如读取一个目录下的所有文件，如果采用单线程模型，则从磁盘读取文件的时候，大部分 CPU 用于等待磁盘去读取数据。如果是采用多线程并发执行，则 CPU 可以在等待 IO 的时候去做其他的事情，以提高 CPU 的使用率，减少资源的浪费。 程序响应速度好 单线程模型下，假设一个 http 请求需要占用大量的时间来处理，则其他的请求无法发送请求给服务端。而多线程模式下，监听线程把请求传递给工作者线程，然后立刻返回去监听，可以去接收新的请求，而工作者线程则能够处理这个请求并发送一个回复给客户端。明显响应速度比单线程模型要好得多。 缺点 程序设计复杂度 多线程情况下，需要考虑线程间的通信、共享资源的访问，相对而言要比单线程程序负责一些。 上下文切换开销大 当 CPU 从执行一个线程切换到执行另外一个线程的时候，它需要先存储当前线程的本地的数据，程序指针等，然后载入另一个线程的本地数据，程序指针等，最后才开始执行。这种切换称为“上下文切换”。 CPU 会在一个上下文中执行一个线程，然后切换到另外一个上下文中执行另外一个线程。尤其是当线程数量较多时，这种开销很明显。 资源消耗

这个可能是最好的对比 volatile 和 synchronized 作用的文章了。 volatile 是一个变量修饰符，而 synchronized 是一个方法或块的修饰符。所以我们使用这两种关键字来指定三种简单的存取变量的方式。 int i1; int geti1() {return i1;} volatile int i2; int geti2() {return i2;} int i3; synchronized int geti3() {return i3;} geti1() 在 当前线程 中立即获取在 i1 变量中的值。线程可以获得变量的本地拷贝，而所获得的变量的值并不一定与其他线程所获得的值相同。特别是，如果其他的线程修改了 i1 的值，那么当前线程获得的 i1 的值可能与修改后的值有所差别。实际上， Java 有一种主内存的机制，使用一个主内存来保存变量当前的正确的值。线程将变量的值拷贝到自己独立的内存中，而这些线程的内存拷贝可能与主内存中的值不同。所以实际当中可能发生这样的情况，在主内存中 i1 的值为 1 ，线程 1 和线程 2 都更改了 i1 ，但是却没把更新的值传回给主内存或其他线程中，那么可能在线程 1 中 i1 的值为 2 ，线程 2 中 i1 的值却为 3 。 另一方面， geti2() 可以有效的从主内存中获取 i2 的值。一个 volatile

尽管面临很多挑战，多线程有一些优点使得它一直被使用。这些优点是： 　　● 资源利用率更好 　　● 程序设计在某些情况下更简单 　　● 程序响应更快 　　资源利用率更好 　　想象一下，一个应用程序需要从本地文件系统中读取和处理文件的情景。比方说，从磁盘读取一个文件需要5秒，处理一个文件需要2秒。处理两个文件则需要： 5秒读取文件A 2秒处理文件A 5秒读取文件B 2秒处理文件B --------------------- 总共需要14秒 　　从磁盘中读取文件的时候，大部分的CPU时间用于等待磁盘去读取数据。在这段时间里，CPU非常的空闲。它可以做一些别的事情。通过改变操作的顺序，就能够更好的使用CPU资源。看下面的顺序： 5秒读取文件A 5秒读取文件B + 2秒处理文件A 2秒处理文件B --------------------- 总共需要12秒 　　CPU等待第一个文件被读取完。然后开始读取第二个文件。当第二文件在被读取的时候，CPU会去处理第一个文件。记住，在等待磁盘读取文件的时候，CPU大部分时间是空闲的。 　　总的说来，CPU能够在等待IO的时候做一些其他的事情。这个不一定就是磁盘IO。它也可以是网络的IO，或者用户输入。通常情况下，网络和磁盘的IO比CPU和内存的IO慢的多。 　　程序设计更简单 　　在单线程应用程序中，如果你想编写程序手动处理上面所提到的读取和处理的顺序

尽管面临很多挑战，多线程有一些优点使得它一直被使用。这些优点是： 资源利用率更好 程序设计在某些情况下更简单 程序响应更快 资源利用率更好 想象一下，一个应用程序需要从本地文件系统中读取和处理文件的情景。比方说，从磁盘读取一个文件需要5秒，处理一个文件需要2秒。处理两个文件则需要： 5秒读取文件A 2秒处理文件A 5秒读取文件B 2秒处理文件B --------------------- 总共需要14秒 从磁盘中读取文件的时候，大部分的CPU时间用于等待磁盘去读取数据。在这段时间里，CPU非常的空闲。它可以做一些别的事情。通过改变操作的顺序，就能够更好的使用CPU资源。看下面的顺序： 5秒读取文件A 5秒读取文件B + 2秒处理文件A 2秒处理文件B --------------------- 总共需要12秒 CPU等待第一个文件被读取完。然后开始读取第二个文件。当第二文件在被读取的时候，CPU会去处理第一个文件。记住，在等待磁盘读取文件的时候，CPU大部分时间是空闲的。 总的说来，CPU能够在等待IO的时候做一些其他的事情。这个不一定就是磁盘IO。它也可以是网络的IO，或者用户输入。通常情况下，网络和磁盘的IO比CPU和内存的IO慢的多。 程序设计更简单 在单线程应用程序中，如果你想编写程序手动处理上面所提到的读取和处理的顺序，你必须记录每个文件读取和处理的状态。相反

以下内容转自 http://ifeve.com/benefits/ ： 尽管面临很多挑战，多线程有一些优点使得它一直被使用。这些优点是： 资源利用率更好 程序设计在某些情况下更简单 程序响应更快 资源利用率更好 想象一下，一个应用程序需要从本地文件系统中读取和处理文件的情景。比方说，从磁盘读取一个文件需要5秒，处理一个文件需要2秒。处理两个文件则需要： 5秒读取文件A 2秒处理文件A 5秒读取文件B 2秒处理文件B --------------------- 总共需要14秒 从磁盘中读取文件的时候，大部分的CPU时间用于等待磁盘去读取数据。在这段时间里，CPU非常的空闲。它可以做一些别的事情。通过改变操作的顺序，就能够更好的使用CPU资源。看下面的顺序： 5秒读取文件A 5秒读取文件B + 2秒处理文件A 2秒处理文件B --------------------- 总共需要12秒 CPU等待第一个文件被读取完。然后开始读取第二个文件。当第二文件在被读取的时候，CPU会去处理第一个文件。记住，在等待磁盘读取文件的时候，CPU大部分时间是空闲的。 总的说来，CPU能够在等待IO的时候做一些其他的事情。这个不一定就是磁盘IO。它也可以是网络的IO，或者用户输入。通常情况下，网络和磁盘的IO比CPU和内存的IO慢的多。 程序设计更简单 在单线程应用程序中

文章目录 1. 简单示例 2. 源码解读 2.1. park 2.2. unpark LockSupport主要用于对线程执行暂停(park)和唤醒(unpark) 1. 简单示例 public class LockSupportTest { static Thread t1,t2 = null; public static void main(String[] args) { t1 = new Thread(()->{ while(true){ System.out.println("t1"); LockSupport.unpark(t2); LockSupport.park(); } }); t2 = new Thread(()->{ while(true){ LockSupport.park(); System.out.println("t2"); LockSupport.unpark(t1); } }); t1.start(); t2.start(); } } 线程1 线程2 启动 线程1 开始打印, 线程2 自锁 线程1 打印完成之后，解锁 线程2 ,然后自锁 线程2 解锁打印，然后解锁 线程1 , 又进入第2步 2. 源码解读 2.1. park public static void park() park当前线程 public static void

多线程之间实现同步 理解线程安全 synchronized用法 死锁 Java内存模型 Vlolatile 关键字 ThreadLock 关键字 理解线程安全 什么是线程安全？ 当多个线程同时对共享的同一个 全局变量或静态变量 做写的操作时 ，可能会发生数据冲突问题，也就是线程安全问题。 但是 做读操作是不会发生数据冲突问题 。 线程安全解决办法 : 使用多线程之间同步synchronized或使用锁(lock)。 原理： 同一时间内，只让当前一个线程进行对数据进行执行操作。当当前线程执行完成后释放锁，才能让其他线程进行操作执行。避免了同时对数据的操作，这样的话就可以解决线程的不安全问题，也就实现了数据的同步。 synchronized用法： synchronized有两种用法： 第一种：将可能会发生线程安全问题的代码，给包括起来，称为同步代码块。 代码如下： synchronized(锁){ 　　//可能会发生线程冲突问题的代码块 } 第二种： 在方法上修饰synchronized，称为同步函数。 代码如下： public synchronized void 方法名() { 　　//可能会发生线程冲突问题的代码块 } 若在方法上加上 static 静态关键字则成为静态同步函数； 静态同步函数使用的锁是该函数所属字节码文件对象； 可以使用 getClass() 的方法获取