java——多线程

进程：

同一个操作系统中执行的一个子程序，包含了三部分虚拟CPU、代码、数据。

进程：

一组独立的数据和内存空间，可以理解为一段程序，进程是有多个线程组成

多进程：

同一个操作系统中执行的多个并行的子程序。可以提高cpu的使用率。

线程：

在同一个进程当中执行的子程序流。

线程：

线程共享一组数据和内存空间就是进程中一个负责程序执行的控制单元(执行路径)
一个进程中可以多执行路径，称之为多线程。

多线程：

同一个进程当中并发执行的多个子程序流。可以提高cpu的使用率。

并发：

进程是并发运行的，OS将时间划分为很多时间片段（时间片），尽可能均匀分配给正在运行的程序， 微观上进程走走停停，宏观上都在运行，这种都运行的现象叫并发，但是不是绝对意义上的“同时发生”。

多线程好处：解决了多部分同时运行的问题。
多线程的弊端：线程太多回到效率的降低。

JVM启动时就启动了多个线程，至少有两个线程可以分析的出来。
1，执行main函数的线程，
该线程的任务代码都定义在main函数中。
2，负责垃圾回收的线程。

进程与线程的区别：

进程有独立的进程空间，进程中的数据存放空间（堆空间和栈空间）是独立的。
线程的堆空间是共享的，栈空间是独立的，线程消耗的资源也比进程小，相互之间可以影响的。

java中如何调进程：
调用本地程序的两个类：
Runtime
Runtime.getRuntime.exec(...); //执行一个程序
其返回值就是Process类型

注意：

只有运行状态的线程才有机会执行代码，主线程的中止不会影响其他的正在运行中的线程，主线程中止也就是main()方法退出了。只有进程中的所有线程都中止时，进程（JVM进程）才会退出，只要有线程没有中止，进程就不会退出。

操作系统决定线程是否有优先级，独占式的操作系统中系统会有优先级的概念，共享式的操作系统则不会有优先级的。

在线程的内部，程序依然顺序执行。

创建线程的目的是为了开启一条执行路径，去运行指定的代码和其他代码实现同时运行。

而运行的指定代码就是这个执行路径的任务。

jvm创建的主线程的任务都定义在了主函数中。

而自定义的线程它的任务在哪儿呢？

Thread类用于描述线程，线程是需要任务的。所以Thread类也对任务的描述。
这个任务就通过Thread类中的run方法来体现。也就是说，run方法就是封装自定义线程运行任务的函数。

run方法中定义就是线程要运行的任务代码。

开启线程是为了运行指定代码，所以只有继承Thread类，并复写run方法。将运行的代码定义在run方法中即可。

线程编程的两种方法
  1. Thread 类
    线程类（Thread）包含一个可以运行的过程（方法）：run()方法。
    2) 创建一个具体线程的步骤如下：
    第一，继承Thread类。
    第二，覆盖run方法（就是更新运行过程），实现用户自己的过程。
    第三，创建线程实例（就是创建一个线程）。
    第四，使用线程实例的start() 方法启动线程, 启动以后线程会尽快的去并发执行run()。
ThreadExtendsDemo ted = new ThreadExtendsDemo("线程1");
ThreadExtendsDemo ted1 = new ThreadExtendsDemo("线程2");
ted.start(); 
ted1.start();
注：

1、main()方法也是一个线程，之前学习的程序都是单线程的，从main()方法开始执行。
2、单核、双核、多核处理器的输出结果都不会一样。

2.Runnable接口
实现步骤：
2、实现Runnable接口, 实现run()方法, 提供并发运程的过程。
3、创建这个类的实例, 用这个实例作为Thread构造器参数，创建Thread类。
4、使用start() 方法启动线程。

 ThreadRunnableDemo trd = new ThreadRunnableDemo();
        new Thread(trd,"线程1").start();
        new Thread(trd,"线程2").start();
实现Runnable接口的好处：

1，将线程的任务从线程的子类中分离出来，进行了单独的封装。
按照面向对象的思想将任务的封装成对象。
2，避免了java单继承的局限性。

所以，创建线程的第二种方式较为常用。

多线程的同步

关键字：synchronized //线程在同步代码中必须采用串行访问
synchronized修饰代码块：对括号内的对象object加锁，只有拿到对象锁标记的线程才能进入该代码块。

synchronized(lock){
lock是自己定义的任意类型的锁对象
}

同步方法

synchronized void saleTicket(){
同步方法也有锁，他的锁是当前调用该方法的对象
}

一个线程可以同时拥有多个对象的锁标记，锁标记如果过多，就会出现线程等待其他线程释放锁标记，而又都不释放自己的锁标记供其他线程运行的状况，造成死锁。

静态方法可以是同步方法：但是它所锁的并不是当前对象，是类对象。

抽象方法不能是synchronized同步的方法。
构造方法不能是synchronized同步的方法。

线程因为未拿到锁标记而发生阻塞进入锁池（lock pool）。每个对象都有自己的一个锁池的空间，用于放置等待运行的线程。由系统决定哪个线程拿到锁标记并运行。

利用Collections类中的synchronizedXxxx(Xxxx ss)方法可以得到相应集合的线程安全的集合。

注意：

在同步语句块中不能直接操作对象锁正在使用的对象。
对象与锁一一对应。
同步依赖对象锁，锁对象相同，同步语句串行，锁对象不同，同步语句并行。
顺序锁，不要回调，反向打开。
能不用同步就不用同步，有数据共享冲突时才使用同步。

等待通知机制：

线程间通信使用的空间称之为对象的等待对列（wait pool），该队列也是属于对象的空间的。
使用Object类中wait()的方法，在运行状态中，线程调用wait()，此时表示线程将释放自己所有的锁标记和CPU的占用，同时进入这个对象的等待池。等待池的状态也是阻塞状态，只不过线程释放自己的锁标记。只有在对该对象加锁的同步代码块里，才能掉用该对象的wait()，表示线程将会释放所有锁标记，进入等待队列，线程将进入等待队列状态。

一个线程进入了一个对对象加锁的同步代码块，并对该对象调用了wait()方法，释放自己拥有的所有锁标记，进入该对象等待队列，另一个线程获得了该对象的锁标记，进入代码块对该对象调用了notify()方法，就会从等待队列里释放出一线程，释放出的这个线程要继续运行就还要进入那个同步代码块，因为得不到要访问代码块对象的锁标记，而进入该对象的锁池，等待锁标记释放。
什么情况下释放锁：
1，同类代码执行完毕。
2，异常未处理，错误退出。
3，调用wait()。

相关方法：
  1. wait()：交出锁和CPU的占用;
  2. notify()：将从对象的等待池中移走一个任意的线程，并放到锁池中，那里的对象一直在等待，直到可以获得对象的锁标记。
  3. notifyAll(): 将从等待池中移走所有等待那个对象的线程并放到锁池中，只有锁池中的线程能获取对象的锁标记，锁标记允许线程从上次因调用wait()而中断的地方开始继续运行
注意：

用notifyAll()取代notify()，因为在调用notify()方法时，是由系统决定释放出哪个线程。
只能对加锁的资源进行wait()和notify()。
判断是否进行等待wait()时，用while代替if来进行判断。

线程安全问题产生的原因：

1，多个线程在操作共享的数据。
2，操作共享数据的线程代码有多条。

当一个线程在执行操作共享数据的多条代码过程中，其他线程参与了运算。
就会导致线程安全问题的产生。

解决思路；
就是将多条操作共享数据的线程代码封装起来，当有线程在执行这些代码的时候，
其他线程时不可以参与运算的。
必须要当前线程把这些代码都执行完毕后，其他线程才可以参与运算。

在java中，用同步代码块就可以解决这个问题。

同步代码块的格式：
synchronized(对象)
{
需要被同步的代码 ；
}

同步的好处：解决了线程的安全问题。

同步的弊端：相对降低了效率，因为同步外的线程的都会判断同步锁。

同步的前提：同步中必须有多个线程并使用同一个锁。

线程的状态

线程的5种状态：

  1. New 新建状态
    当程序使用new关键字创建了一个线程后，该线程就处于新建状态，此时线程还未启动，当线程对象调用start()方法时，线程启动，进入Runnable状态。
  2. Runnable 可运行（就绪）状态
    当线程处于Runnable状态时，表示线程准备就绪，等待获取CPU。
  3. Running 运行（正在运行）状态
    假如该线程获取了CPU，则进入Running状态，开始执行线程体，即run()方法中的内容。
注意：

如果系统另有1个CPU，那么在任意时间点则另有1条线程处于Running状态； 如果是双核系统，那么同一时间点会有2条线程处于Running状态。但是，当线程数大于处理器数时，依然会是多条线程在同一个CPU上轮换执行。
当一条线程开始运行时，如果它不是一瞬间完成，那么它不可能一直处于Running状态，线程在执行过程中会被中断，目的是让其它线程获得执行的机会，像这样线程调度的策略取决于底层平台。对于抢占式策略的平台而言，系统系统会给每个可执行的线程一小段时间来处理任务，当该时间段（时间片）用完，系统会剥夺该线程所占资源（CPU），让其他线程获得运行机会。

调用yield()方法，可以使线程由Running状态进入Runnable状态。
  1. Block 阻塞（挂起）状态
    当如下情况下，线程会进入阻塞状态：
    1、线程调用了sleep()方法主动放弃所占CPU资源。
    2、线程调用了一个阻塞式IO方法（比如控制台输入方法），在该方法返回前，该线程被阻塞。
    当正在执行的线程被阻塞时，其它线程就获得执行机会了。需要注意的是，当阻塞结束时，该线程将进入Runnable状态，而非直接进入Running状态。
  2. Dead 死亡状态
    1、当线程的run()方法执行结束，线程进入Dead状态。
    2、需要注意的是，不要试图对一个已经死亡的线程调用start()方法，线程死亡后将不能再次作为线程执行，系统会抛出IllegalThreadStateException异常。

注：
1) new运算创建线程后，线程进入New状态（初始状态）。
2) 调用 start()方法后，线程从New状态进入Runnable状态（就绪状态）。
start()方法是在main()方法（Running状态）中调用的。
3) 线程结束后，进入Dead状态（死亡状态），被对象垃圾回收。
4) main()方法结束后，其它线程，比如上例中p1和p2开始抢着进入Running状态。
1、由谁抢到是底层操作系统决定（操作系统分配时间片）。
2、单核处理器：在一个时间点上另有一个线程在Running状态；双核处理器：2个。
3、如果p1进入Running状态，当操作系统分配给它的时间片到期时，p1进入Runnable状态，p2进入Running状态。
4、在期间有可能其它的进程的线程获得时间片，那么p1和p2同时进入Runnable状态，等待操作系统分配时间片。
5) 线程进入Dead状态后，另能被垃圾回收，不能再开始。
6) 如果线程在运行过程中，自己调用了yield()方法，则主动由Running状态进入Runnable状态。

等待/唤醒机制。

涉及的方法：
1，wait(): 让线程处于冻结状态，被wait的线程会被存储到线程池中。
2，notify():唤醒线程池中一个线程(任意).
3，notifyAll():唤醒线程池中的所有线程。
这些方法都必须定义在同步中。
因为这些方法是用于操作线程状态的方法。
必须要明确到底操作的是哪个锁上的线程。

为什么操作线程的方法wait notify notifyAll定义在了Object类中？

因为这些方法是监视器的方法。监视器其实就是锁。
锁可以是任意的对象，任意的对象调用的方式一定定义在Object类中。
sleep()和wait()
sleep：Thread类中定义的方法，表示线程休眠，会自动唤醒；
wait：Object中定义的方法，需要手工调用notify()或者notifyAll()方法。
sleep是线程类（Thread）的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用sleep不会释放对象锁。

wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法（或notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。
sleep就是正在执行的线程主动让出cpu，cpu去执行其他线程，在sleep指定的时间过后，cpu才会回到这个线程上继续往下执行，如果当前线程进入了同步锁，sleep方法并不会释放锁，即使当前线程使用sleep方法让出了cpu，但其他被同步锁挡住了的线程也无法得到执行。

wait是指在一个已经进入了同步锁的线程内，让自己暂时让出同步锁，以便其他正在等待此锁的线程可以得到同步锁并运行，只有其他线程调用了notify方法（notify并不释放锁，只是告诉调用过wait方法的线程可以去参与获得锁的竞争了，但不是马上得到锁，因为锁还在别人手里，别人还没释放。如果notify方法后面的代码还有很多，需要这些代码执行完后才会释放锁，可以在notfiy方法后增加一个等待和一些代码，看看效果），调用wait方法的线程就会解除wait状态和程序可以再次得到锁后继续向下运行

  1. Thread.sleep(times)。
    使当前线程从 Running状态放弃处理器，进入Block状态，休眠times（单位为毫秒），休眠结束
  2. interrupt() 方法打断/中断。
    使用该方法可以让一个线程提前唤醒另外一个sleep Block的线程。
  3. 被唤醒线程会出现中断异常。
线程常用的属性和方法
  1. 线程的优先级 (资源紧张时候，尽可能优先)
    1、t3.setPriority(Thread.MAX_PRIORITY); 设置为最高优先级。
    2、默认有10优先级，优先级高的线程获得执行（进入Running状态）的机会多，机会的多少不能通过代码干预。
    3、默认的优先级是 5
  2. 后台线程（守护线程，精灵线程）
    1、t1.setDaemon(true);
    2、Java进程的结束：当前所有前台线程都结束时，Java进程结束。
    3、当前台线程结束时， 不管后台线程是否结束，都要被停掉！
  3. 获得线程名字
    getName()
  4. 获得当前线程
    Thread main = Thread.currentThread();
    5）线程让步
    Yield();
    6)线程插队
    Join();
知识补充

jdk1.5以后将同步和锁封装成了对象。
并将操作锁的隐式方式定义到了该对象中，
将隐式动作变成了显示动作。

Lock接口： 出现替代了同步代码块或者同步函数。将同步的隐式锁操作变成现实锁操作。
同时更为灵活。可以一个锁上加上多组监视器。
lock():获取锁。
unlock():释放锁，通常需要定义finally代码块中。

Condition接口：出现替代了Object中的wait notify notifyAll方法。
将这些监视器方法单独进行了封装，变成Condition监视器对象。
可以任意锁进行组合。
await();
signal();
signalAll();

//创建一个锁对象。
Lock lock = new ReentrantLock();

//通过已有的锁获取该锁上的监视器对象。
Condition con = lock.newCondition();

多线程总结：

1，进程和线程的概念。
|--进程：
|--线程：

2，jvm中的多线程体现。
|--主线程，垃圾回收线程，自定义线程。以及他们运行的代码的位置。

3，什么时候使用多线程，多线程的好处是什么？创建线程的目的？
|--当需要多部分代码同时执行的时候，可以使用。

4，创建线程的两种方式。★★★★★
|--继承Thread
|--步骤
|--实现Runnable
|--步骤
|--两种方式的区别？

5，线程的5种状态。
对于执行资格和执行权在状态中的具体特点。
|--被创建：
|--运行：
|--冻结：
|--临时阻塞：
|--消亡：

6，线程的安全问题。★★★★★
|--安全问题的原因：
|--解决的思想：
|--解决的体现：synchronized
|--同步的前提：但是加上同步还出现安全问题，就需要用前提来思考。
|--同步的两种表现方法和区别：
|--同步的好处和弊端：
|--单例的懒汉式。
|--死锁。

7，线程间的通信。等待/唤醒机制。
|--概念：多个线程，不同任务，处理同一资源。
|--等待唤醒机制。使用了锁上的 wait notify notifyAll. ★★★★★
|--生产者/消费者的问题。并多生产和多消费的问题。 while判断标记。用notifyAll唤醒对方。 ★★★★★
|--JDK1.5以后出现了更好的方案，★★★
Lock接口替代了synchronized
Condition接口替代了Object中的监视方法，并将监视器方法封装成了Condition
和以前不同的是，以前一个锁上只能有一组监视器方法。现在，一个Lock锁上可以多组监视器方法对象。
可以实现一组负责生产者，一组负责消费者。
|--wait和sleep的区别。★★★★★

8，停止线程的方式。
|--原理：
|--表现：--中断。

9，线程常见的一些方法。
|--setDaemon()
|--join();
|--优先级
|--yield();
|--在开发时，可以使用匿名内部类来

©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 211,265评论 6赞 490
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 90,078评论 2赞 385
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 156,852评论 0赞 347
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 56,408评论 1赞 283
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 65,445评论 5赞 384
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 49,772评论 1赞 290
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 38,921评论 3赞 406
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 37,688评论 0赞 266
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 44,130评论 1赞 303
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 36,467评论 2赞 325
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,617评论 1赞 340
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 34,276评论 4赞 329
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 39,882评论 3赞 312
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,740评论 0赞 21
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,967评论 1赞 265
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 46,315评论 2赞 360
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 43,486评论 2赞 348

推荐阅读更多精彩内容

  • Java多线程
    进程和线程 进程 所有运行中的任务通常对应一个进程,当一个程序进入内存运行时,即变成一个进程.进程是处于运行过程中...
    小徐andorid阅读 2,799评论 3赞 53
  • Java多线程学习
    Java多线程学习 [-] 一扩展javalangThread类 二实现javalangRunnable接口 三T...
    影驰阅读 2,952评论 1赞 18
  • Java多线程学习（吐血超详细总结）
    该文章转自：http://blog.csdn.net/evankaka/article/details/44153...
    加来依蓝阅读 7,336评论 3赞 87
  • java多线程
    本文主要讲了java中多线程的使用方法、线程同步、线程数据传递、线程状态及相应的一些线程函数用法、概述等。 首先讲...
    李欣阳阅读 2,444评论 1赞 15
  • 《金字塔原理》读后感
    ——王维宁 《金字塔原理》这本书是一本致力于解决“思考、写作、解决问题和演示逻辑”的书，贯穿全书的是作者一直强调的...
    MrFace阅读 1,072评论 1赞 0