线程

线程 并发 ：指两个或多个事件在 同一个时间段内 发生。 并行 ：指两个或多个事件在 同一时刻 发生（同时发生）。 进程 ：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。 线程 ：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。 简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程 多次启动一个线程是非法的。当线程已经结束后，不能重新启动。 Java程序属于抢占式调度，那个线程优先级高优先执行那个程序，同一优先级的线程随机选择执行。 多线程内存图解 创建线程第一种方法： 自定义线程类： public class MyThread extends Thread { /* * 利用继承中的特点 * 将线程名称传递 进行设置 */ public MyThread ( String name ) { super ( name ) ; } /* * 重写run方法 * 定义线程要执行的代码 */ @Override public void run ( ) { for ( int i = 0 ; i < 20 ; i ++ )

转自：http://www.cnblogs.com/aigongsi/archive/2012/04/01/2429166.html 在java线程并发处理中，有一个关键字volatile的使用目前存在很大的混淆，以为使用这个关键字，在进行多线程并发处理的时候就可以万事大吉。 Java语言是支持多线程的，为了解决线程并发的问题，在语言内部引入了 同步块 和 volatile 关键字机制。 synchronized 同步块大家都比较熟悉，通过 synchronized 关键字来实现，所有加上synchronized 和 块语句，在多线程访问的时候，同一时刻只能有一个线程能够用 synchronized 修饰的方法 或者 代码块。 volatile 用volatile修饰的变量，线程在每次使用变量的时候，都会读取变量修改后的最的值。volatile很容易被误用，用来进行原子性操作。 下面看一个例子，我们实现一个计数器，每次线程启动的时候，会调用计数器inc方法，对计数器进行加一 执行环境——jdk版本：jdk1.6.0_31 ，内存 ：3G cpu：x86 2.4G public class Counter { public static int count = 0; public static void inc() { //这里延迟1毫秒，使得结果明显 try { Thread

打印指定线程调用栈： /** * 自定义打印调用栈: * @param currentThread 根据当前线程 */ public static void printCallStatck(Thread currentThread) { StackTraceElement[] stackElements = currentThread.getStackTrace(); if (stackElements != null) { System.out.println("-----------------------------------"); for (int i = 0; i < stackElements.length; i++) { System.out.print(stackElements[i].getClassName() + "--"); System.out.print(stackElements[i].getLineNumber() + "--"); System.out.println(stackElements[i].getMethodName()); } System.out.println("-----------------------------------"); } } PS：可以应用于基础库方法调用分析，被哪些方法调用，是否正常调用。 举例

1、Java实现多线程目的 Java中实现多线程 利计算机 多核cup并行 处理多个线程， 提升CUP的利用率，提升程序的处理速度。 当使用多线程进行并发编程时，当有共享资源时，就需要我们考虑线程安全问题。 如下图，假设改计算机有3个CUP，单对共享变量进行自增时。 cup在处理时，会将共享内存缓存到L1,L2,L3高速缓存中，当三个线程同时对i进行自增时，在缓存中拷贝的都是不可以预测，造成自增后的结果也是不可以预测，总是会小于或者等于3 public class ThreadDemo1 implements Runnable { private static int i=0; @Override public void run() { try { Thread.sleep(400); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } increment(); System.out.println("完成处理"); } public /*synchronized */void increment() { i++; } public static void main(String[] args) { ThreadDemo1 task=new

我们提供了一个类： public class Foo { public void one() { print("one"); } public void two() { print("two"); } public void three() { print("three"); } } 三个不同的线程将会共用一个 Foo 实例。 线程 A 将会调用 one() 方法 线程 B 将会调用 two() 方法 线程 C 将会调用 three() 方法 请设计修改程序，以确保 two() 方法在 one() 方法之后被执行，three() 方法在 two() 方法之后被执行。 示例 1: 输入: [1,2,3] 输出: “onetwothree” 解释: 有三个线程会被异步启动。 输入 [1,2,3] 表示线程 A 将会调用 one() 方法，线程 B 将会调用 two() 方法，线程 C 将会调用 three() 方法。 正确的输出是 “onetwothree”。 示例 2: 输入: [1,3,2] 输出: “onetwothree” 解释: 输入 [1,3,2] 表示线程 A 将会调用 one() 方法，线程 B 将会调用 three() 方法，线程 C 将会调用 two() 方法。 正确的输出是 “onetwothree”。 注意: 尽管输入中的数字似乎暗示了顺序

　　并发：指多线程交替执行 　　并行：指同时执行 1、上下文切换 　　并不是启动更多的线程就能让程序最大限度的并发执行，多线程会面临上下文的切换，死锁问题。 　　CPU通过给每个线程分配时间片，即线程的执行时间，通常非常短，一般是几十毫秒，因此CPU通过不停的切换线程执行。在切换前会保留上一个任务的状态，以便下次切换回在这个任务 来源： https://www.cnblogs.com/yangyongjie/p/12402498.html

1. JVM 线程私有内存 : 程序计数器(Program Counter Register)：保留当前线程执行方法 Java虚拟机栈(JVM Stack)：方法的栈帧 本地方法栈(Native Method Stack)：存储native方法信息 多线程共享内存 : 堆(Heap)：存储对象和数组 方法区(Method Area)：存储类结构/常量/静态变量,运行时常量池：属于方法区 1.1. 程序计数器 程序计数器（Program Counter Register）是一块较小的内存空间，它可以看做是当前线程所执行的字节码的 行号指示器 。在虚拟机的概念模型里（仅是概念模型，各种虚拟机可能会通过一些更高效的方式去实现），字节码解释器工作时就是通过改变这个计数器的值来选取下一条需要执行的字节码指令，分支、循环、跳转、异常处理、线程恢复等基础功能都需要依赖这个计数器来完成。 1.2. Heap Java 堆(Java Heap)是Java 虚拟机所管理的内存中最大一块。Java 堆是被所有线程共享的一块内存区域,在虚拟机启动时创建。此内存区域用来 存放对象实例 ,几乎所有的对象实例都在这里分配内存，垃圾回收器也主要在堆内工作。 java堆：分为新生代和老年代， 老年代进行fullGC: 或者使用system.gc 老年代满后 java heap详解 java性能调优的目的 ：

什么是 ThreadLocal？ ThreadLocal 诞生于 JDK 1.2，用于解决多线程间的数据隔离问题。也就是说 ThreadLocal 会为每一个线程创建一个单独的变量副本。 ThreadLocal 有什么用？ ThreadLocal 最典型的使用场景有两个： ThreadLocal 可以用来管理 Session，因为每个人的信息都是不一样的，所以就很适合用 ThreadLocal 来管理； 数据库连接，为每一个线程分配一个独立的资源，也适合用 ThreadLocal 来实现。 其中，ThreadLocal 也被用在很多大型开源框架中，比如 Spring 的事务管理器，还有 Hibernate 的 Session 管理等，既然 ThreadLocal 用途如此广泛，那接下来就让我们共同看看 ThreadLocal 要怎么用？ThreadLocal 使用中要注意什么？以及 ThreadLocal 的存储原理等，一起来看吧。 ThreadLocal 基础使用 ThreadLocal 常用方法有 set(T)、get()、remove() 等，具体使用请参考以下代码。 ThreadLocal threadLocal = new ThreadLocal(); // 存值 threadLocal.set(Arrays.asList( "老王" , "Java 面试题" )); /

单线程。 cpu核心的缓存只被一个线程访问。缓存独占，不会出现访问冲突等问题。 单核CPU，多线程。 进程中的多个线程会同时访问进程中的共享数据，CPU将某块内存加载到缓存后，不同线程在访问相同的物理地址的时候，都会映射到相同的缓存位置，这样即使发生线程的切换，缓存仍然不会失效。但由于任何时刻只能有一个线程在执行，因此不会出现缓存访问冲突。 多核CPU、多线程情况下存在缓存不一致的情况 每个核都至少有一个L1 缓存。多个线程访问进程中的某个共享内存，且这多个线程分别在不同的核心上执行，则每个核心都会在各自的caehe中保留一份共享内存的缓冲。由于多核是可以并行的，可能会出现多个线程同时写各自的缓存的情况，而各自的cache之间的数据就有可能不同。 在CPU和主存之间增加缓存，在多线程场景下就可能存在 缓存一致性问题 ，也就是说，在多核CPU中，每个核的自己的缓存中，关于同一个数据的缓存内容可能不一致。 理解为： 如果这家公司的命令都是串行下发的话，那么就没有任何问题。 如果这家公司的命令都是并行下发的话，并且这些命令都是由同一个CEO下发的，这种机制是也没有什么问题。因为他的命令执行者只有一套管理体系。 如果这家公司的命令都是并行下发的话，并且这些命令是由多个合伙人下发的，这就有问题了。因为每个合伙人只会把命令下达给自己直属的管理人员，而多个管理人员管理的底层员工可能是公用的。

1. 继承Thread类 继承Thread类之后重写run方法,在主函数中新建刚刚创建的子类对象调用start方法完成线程任务 public class MyThread extends Thread { @Override public void run ( ) { for ( int i = 0 ; i < 20 ; i ++ ) { System . out . println ( "继承Thread类创建线程" + Thread . currentThread ( ) . getName ( ) + "-->" + i ) ; } } } 2.实现Runnable接口 实现Runable接口,重写Runnable接口中的run方法,新建Thread对象,Thread类中有一个构造方法可以接收Runnable接口的实现类,这时就可以调用新建Thread对象的start方法来完成线程任务 public Thread ( Runnable target ) { init ( null , target , "Thread-" + nextThreadNum ( ) , 0 ) ; } 3.两种方法的测试类And匿名内部类的实现方法 public class DemoThread { public static void main ( String [ ] args ) { //1