标签：
线程与进程的概述：
要想了解多线程，必须先了解线程，要想了解线程，必须了解进程，因为线程是依赖于进程而存在
什么是进程？
通过任务管理器我们就看到了进程的存在
而通过观察，我们发现只有运行的程序才会出现进程。
进程：就是正在运行的程序
进程是系统进行资源分配和调用的独立单位。每一个进程都有它自己的内存空间和系统资源
多进程有什么意义呢？
单进程的计算机只能进做一件事情，而我们现在的计算机都可以做多件事情
举例：一遍玩游戏（游戏进程），一边听音乐）（音乐进程）
也就是说现在的计算机都是支持多线程的，就可以在一个时间段内执行多个任务，并且呢，可以提高CPU的使用率
问题：
一边玩游戏，一边听音乐是同时进行的呢？
不是 。因为单CPU在某一时间点上只能做一件事情
而我们在玩游戏，或者听音乐的时候，CPU在作者程序间的高效谢欢让我们觉得是同时进行的
什么是线程呢？
在同一个进程内又可以执行多个任务，而这每一个任务我们就可以看成是一个线程
线程：是程序的执行单元，执行路径。是程序使用CPU的最基本单位
单线程：如果程序只有一条执行路径
多线程：如果程序有多条执行路径
多线程有什么意义呢？
多线程的存在，不是提高程序的执行速度，其实是为了提高程序的使用率
程序的执行其实都是在抢CPU的资源，CPU的执行权
多个进程是在抢这个资源，而其中的某一个进程如果执行的路径比较多，就会有更高的几率抢到CPU的执行权
我们是不敢保证呢一个线程能够在哪个时刻抢到CPU执行权，所以线程的执行有随机性
/*
* 进程：
* 正在运行的程序，是系统进行资源分配合调用的独立单位
* 每一个进程都有自己的内存空间和系统资源
* 线程：
* 是进程中的单个顺序控制流，是一条执行路径
* 一个进程中如果只有一条执行路径，则被称为单线程程序
* 一个进程如果有多条执行路径，则被称为多线程程序
* 举例：
* 扫雷，迅雷下载
*
* 大家注意两个词汇的区别：并发和并行
* 前者是逻辑上同事发生，指的是在某一个时间内同事运行多个程序
* 后者是物理上同事发生，指的是在某一个时间点同事运行多个程序
*
* java程序的运行原理：
* 由java命令启动JVM，JVM启动就相当于启动了一个进程
* 接着该进程创建了一个主线程去调main方法
*
* 思考题：
* jvm虚拟机的启动是单线程的还是多线程的？
* 多线程的
* 原因是垃圾回收线程也要先启动，否则很容易出现内存溢出
* 现在垃圾回收线程加上前面的主线程，最低启动了两个线程，所以JVM虚拟机是多线程的
第一个多线程：
package com.gz_02; /* * 需求：我们要实现多线程的程序 * 如何实现呢？ * 由于线程是依赖进程而存在的，所以我们应该先创建一个进程出来 * 而进程是由系统创建的，所以我们应该去调用系统功能创建一个系统 * java是不能直接调用系统功能的，所以我们没有办法直接实现多线程程序 * 但是呢？Java可以去调用C/C++写好的程序来实现多线程程序 * 由C/C++去调用系统功能创建进程，然后由Java去调用这样的东西 * 然后提供一些类供我么使用，我们就可以实现多线程程序了 * 那么Java提供的类是什么呢？ * Thread * 通过查看API，我们发现有两种方式实现多线程程序 * * 方式1：将类声明为Threa的子类 * 步骤： * A：自定义MyThread继承Thread类 * B：MyThread类重写run()方法 * 为什么是run()方法呢？ * C:创建对象 * D:启动线程 */ public class MyThreadDemo { public static void main(String[] args) { //创建线程对象 // MyThread my=new MyThread(); //启动线程 // my.run(); // my.run(); //调用run()为什么是单线程的呢？ //因为run()方法直接调用就相当于普通的方法调用，所以你看到的是单线程的效果 //要想看到多线程的效果，就必须使用另一个方法：start() //面试题： //run()和start()的区别 //run()：仅仅是封装被线程执行的代码，直接调用时普通方法 //start():首先启动了线程，然后再由jvm开启线程，走线程的run() // my.start(); //java.lang.IllegalThreadStateException非法的线程状态异常 //为什么呢？因为这个相当于是my线程被调用了两次，而不是两个线程启动 // my.start(); //创建两个线程对象 MyThread my1=new MyThread(); MyThread my2=new MyThread(); my1.start(); my2.start(); } } package com.gz_02; /* * 该类要重写run()方法，为什么呢？ * 不是类里的所有代码都需要被线程执行，而这个时候，为了区分哪些代码能够被线程执行，java提供了Thread的run()来包含那些被线程执行的代码 */ public class MyThread extends Thread{ @Override public void run(){ //自己写代码 // System.out.println("好好学习，天天向上"); //一般来说，被线程执行的方法肯定是比较耗时的，所以我们先使用循环 for(int i=0;i<300;i++){ System.out.println(i); } } }
设置获取线程名称：
package com.gz_03; /* * 如何获取线程对象名称？ * public final String getName() * 如何设置线程对象名称？ * public final void setName(String str) * *我想要获取main方法的线程对象的名称，怎么办呢？ * public static Thread currentThread() 返回正在执行的线程对象 */ public class MyThreadDemo { public static void main(String[] args) { // MyThread my1=new MyThread(); // MyThread my2=new MyThread(); // // my1.setName("A"); // my2.setName("B"); //使用构造给名字 // MyThread my1=new MyThread("A"); // MyThread my2=new MyThread("B"); // my1.start(); // my2.start(); System.out.println(Thread.currentThread().getName()); } } package com.gz_03; public class MyThread extends Thread{ @Override public void run() { for(int i=0;i<300;i++){ System.out.println(getName()+"---------"+i); } } public MyThread(){ } public MyThread(String name){ super(name); } }
线程调度：
假如我们的计算机只有一个CPU，那么CPU在某一个时刻只能执行一条指令，线程只有得到CPU的时间片，也就是使用权
才可以执行指令。那么java是如何对线程进行调用的呢？
线程有两种调度模型：
分时调度模型：
所有线程轮流使用CPU使用权，平均分配每个线程占用CPU的时间片
抢占式调动模式：
有限让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的CPU时间片相对多一点
java使用的是抢占式调度模型
线程的优先级：
package com.gz_04; public class ThreadPriority extends Thread{ public void run(){ for(int i=0;i<300;i++){ System.out.println(getName()+"\t"+i); } } } package com.gz_04; /* * int getPriority() 返回线程的优先级。 * void setPriority(int newPriority) 更改线程的优先级 * * 注意： * 优先级在线程的MAX_PRIORITY和MIN_PRIORITY之间。默认的是NORM_PRIORITY * 优先级的范围是：1~10，默认5 * 线程优先级仅仅表示获取CPU时间片的几率，往往在多次运行更容易看到效果，因为线程调度存在随机性 * */ public class ThreadPriorityDemo { public static void main(String[] args) { ThreadPriority tp1=new ThreadPriority(); ThreadPriority tp2=new ThreadPriority(); ThreadPriority tp3=new ThreadPriority(); tp1.setName("东方不败"); tp1.setPriority(10); tp2.setName("岳不群"); tp2.setPriority(1); tp3.setName("林平之"); // tp1.setPriority(100); System.out.println(tp1.getPriority()); System.out.println(tp2.getPriority()); System.out.println(tp3.getPriority()); System.out.println(Thread.MAX_PRIORITY);//10 System.out.println(Thread.MIN_PRIORITY);//5 System.out.println(Thread.NORM_PRIORITY);//1 tp1.start(); tp2.start(); tp3.start(); } }
线程的休眠：
package com.gz_04; import java.util.Date; public class ThreadSleep extends Thread{ @Override public void run() { for(int i=0;i<100;i++){ System.out.println(getName()+":"+i+"\t日期："+(new Date())); //睡觉 //困了，休息1秒钟 try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } } package com.gz_04; /* * static void sleep(long millis) * 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。 */ public class ThreadSleepDemo { public static void main(String[] args) { ThreadSleep ts1=new ThreadSleep(); ThreadSleep ts2=new ThreadSleep(); ThreadSleep ts3=new ThreadSleep(); ts1.setName("A"); ts2.setName("B"); ts3.setName("C"); ts1.start(); ts2.start(); ts3.start(); } }
停止、中断线程：
package com.gz_04; import java.util.Date; public class ThreadStop extends Thread{ @Override public void run() { System.out.println("开始执行："+new Date()); //我要休息10秒钟，亲，不要打扰我 try { Thread.sleep(10000); } catch (InterruptedException e) { System.out.println("线程被终止了"); } System.out.println("结束执行："+new Date()); } } package com.gz_04; /* * public final void stop() :让线程停止，过时了，但是还可以使用 * public void interrupt():中断线程.把线程的状态终止，并抛出一个InterruptedException */ public class ThreadStopDemo { public static void main(String[] args) { ThreadStop ts=new ThreadStop(); ts.start(); //你超过3秒不醒过来，我就停止你 try { Thread.sleep(3000); // ts.stop(); ts.interrupt(); } catch (InterruptedException e) { // TODO Auto-generated catch block } } }
守护线程：
package com.gz_04; public class ThreadDaemon extends Thread{ public void run(){ for(int i=0;i<100;i++){ System.out.println(getName()+"\t"+i); } } } package com.gz_04; /* * public final void setDaemon(boolean on):将该线程标记为守护线程 * 当正在运行的线程都是守护线程的时候，java虚拟机退出。该方法在启动线程前调用 */ public class ThreadDaemonDemo { public static void main(String[] args) { ThreadDaemon td1=new ThreadDaemon(); ThreadDaemon td2=new ThreadDaemon(); td1.setName("关羽"); td2.setName("张飞"); Thread.currentThread().setName("刘备"); td1.setDaemon(true); td2.setDaemon(true); td1.start(); td2.start(); for(int x=0;x<100;x++){ System.out.println(Thread.currentThread().getName()+":"+x); } } }
等待线程终止或者等待一段时间或线程终止，才往下执行：
package com.gz_04; /* * void join() 等待该线程终止。 * void join(long millis) 等待该线程终止的时间最长为 millis 毫秒。 */ public class TetsThreadJoin { public static void main(String[] args) { ThreadJoin tj1=new ThreadJoin(); ThreadJoin tj2=new ThreadJoin(); ThreadJoin tj3=new ThreadJoin(); tj1.setName("李渊"); tj2.setName("李元霸"); tj3.setName("李世民"); tj1.start(); try { tj1.join(); } catch (InterruptedException e) { e.printStackTrace(); } tj2.start(); tj3.start(); } } package com.gz_04; public class ThreadJoin extends Thread{ public void run(){ for(int i=0;i<100;i++){ System.out.println(getName()+"\t"+i); } } }
礼让线程：
package com.gz_04; /* * public static void yield():暂停当前正在执行的线程对象，并执行其他线程 * 让多个线程的执行更和谐，但不能保证一人一次 */ public class ThreadYieldDemo { public static void main(String[] args) { ThreadYield ty1=new ThreadYield(); ThreadYield ty2=new ThreadYield(); ty1.setName("A"); ty2.setName("B"); ty1.start(); ty2.start(); } } package com.gz_04; public class ThreadYield extends Thread{ @Override public void run() { for(int i=0;i<100;i++){ System.out.println(getName()+":"+i); Thread.yield(); } } }
第二种多线程的方式：实现接口
package com.gz_05; public class MyThread extends Thread{ @Override public void run() { for(int i=0;i<100;i++){ System.out.println(getName()+":"+i); } } } /* 实现多线程的两种方式： 继承Thread类 自定义对象继承Thread类 重写run() 创建自定义的的对象 启动线程对象 为什么要重写run() run()里封装的是被线程执行的代码 启动线程对象使用的是哪个方法 start() run()和start()的区别 run()直接调用相当于普通方法 start()相当于先启动线程，然后JVM调用run() 方式2：实现Runnable接口 A:自定义类MyRunnable实现Runnable接口 B:在MyRunnable里面重写run方法 C:创建MyRunnable对象 D:创建Thread对象，将MyRunnable对象做为构造方法参数传递 E:启动线程对象 问题： 有了方式1，为什么还要方式2？ A:可以避免由于java单继承带来的局限性 B:适合多个相同程序的代码去处理同一个资源的情况，把线程同程序的代码、数据有效分离，较好的体现了面向对象的设计思想 */ package com.gz_05; public class MyRunnable implements Runnable{ @Override public void run() { for(int x=0;x<100;x++){ //由于实现接口的方式，就不能直接使用Thread类的方法，但是可以间接使用 System.out.println(Thread.currentThread().getName()+":"+x); } } } package com.gz_05; /* * 方式2：实现Runnable接口 * 步骤： * A:自定义类MyRunnable实现Runnable接口 * B:重写run()方法 * C:创建MyRunnable类的对象 * D:创建Thread类的对象，将C步骤的对象做为参数传递 */ public class MyRunnableDemo { public static void main(String[] args) { MyRunnable my=new MyRunnable(); // Thread t1=new Thread(my); // Thread t2=new Thread(my); // t1.setName("A"); // t2.setName("B"); Thread t1=new Thread(my,"A"); Thread t2=new Thread(my,"B"); t1.start(); t2.start(); } }
卖票问题：
package com.test; /* * 需求： * 某电影院正在上映贺岁大片，共有100张票，而它有3个售票窗口，请设计一个程序模拟该电影院售票 * 两种方式实现：继承Thread类、实现Runnable接口 */ public class Test01 { public static void main(String[] args) { // MyTicketThread mtt1=new MyTicketThread(); // MyTicketThread mtt2=new MyTicketThread(); // MyTicketThread mtt3=new MyTicketThread(); // mtt1.setName("窗口1"); // mtt2.setName("窗口2"); // mtt3.setName("窗口3"); MyTicket1Thread mt=new MyTicket1Thread(); Thread mtt1=new Thread(mt,"窗口1"); Thread mtt2=new Thread(mt,"窗口2"); Thread mtt3=new Thread(mt,"窗口3"); mtt1.start(); mtt2.start(); mtt3.start(); } } class MyTicketThread extends Thread{ private static int ticketCount=100; @Override public void run() { for(;ticketCount>0;ticketCount--){ System.out.println(getName()+"卖票编号"+ticketCount); } } } class MyTicket1Thread implements Runnable{ private int ticketCount=100; // public void run() { // for(;ticketCount>0;ticketCount--){ // // System.out.println(Thread.currentThread().getName()+"卖票编号"+ticketCount); // } // // } @Override public void run() { /* * 通过加入延迟后发现了两个问题： * A:相同票卖了多次 * B: 卖负票 */ while(true){ if(ticketCount>0){ //为了模拟真实场景，我们稍作休息 try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+"正在卖"+(ticketCount--)+"张票"); } } } }
卖票问题引发了同步问题：同步代码块与同步方法
package com.gz_06; /* * 同步的特点： * 前提： * 多个线程 * 解决问题的时候需要注意： * 多个线程使用的是同一个所对象 *同步的好处 * 同步的出现出现了解决多线程的安全问题 *同步的弊端 * 当线程相当多的时候，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率 *有同步代码块，也可以有同步方法 * *同步方法就是指该方法的所有代码都是同步的 * *格式： * public synchronized void methodname(){ * * } *基本同步方法的锁是什么呢？ * 判断方法： * 在调用同步方法之前也写一个同步代码块，然后两个同步的地方应该是选择关系，如果代码块的对象与同步方法的对象是一样的，那么数据就会实现同步。否则。。。 *测试知道：它的同步锁对象是this，也就是它本身的对象 * *static 同步方法的锁是什么呢？ *测试知道：它的同步的锁是加载的Class对象，因为static是属于Class对象的 **/ public class SellTicket implements Runnable{ private static int tickets=100; // private Object obj=new Object(); @Override public void run() { // while(true){ // synchronized (obj) { // if(tickets>0){ // try { // Thread.sleep(100); // } catch (InterruptedException e) { // e.printStackTrace(); // } // System.out.println(Thread.currentThread().getName()+"正在出售第"+(tickets--)+"张票"); // }else{ // break; // } // } // } while(true){ int c=tickets%2; if(tickets==0){ // method1(); method2(); }else{ synchronized(SellTicket.class){ if(tickets>0){//刚才我将if判断放在同步锁外部，就出现了问题。以后判断还是要注意啊 try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+"正在出售第"+(tickets--)+"张票"); } } } } } public synchronized void method1(){ if(tickets>0){ try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+"正在出售第"+(tickets--)+"张票"); } } public static synchronized void method2(){ if(tickets>0){ try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+"正在出售第"+(tickets--)+"张票"); } } } package com.gz_06; /* * 前面卖票问题我们知道是线程安全问题，如何解决呢？ * * 要想解决问题，就要知道哪些问题会导致出问题：（而且这些原因也是我们判断一个程序是否会有线程安全问题的标准） * A:是否是多线程环境 * B:是否有共享数据 * C:是否有多条语句操作共享数据 * * 我们来回想一下我们的程序 * A:是否多线程程序： 是 * B:是否有共享数据：是 * C:是否有多条语句操作共享数据：是 * * 由此可见，我们的程序出现问题是正常的，因为它满足出现问题的条件 * 接下来才是我们想想如何解决问题呢？ * 思想： * 把多条语句操作共享数据的代码给封装起来，一个线程访问的时候不允许其他线程访问 * 怎么将语句封装起来呢？java提供了同步机制 * * 同步代码块： * synchronized(对象){ * 需要同步的代码块 * } * A：对象是什么呢？ * 我们可以随便创建一个对象试试 * B:需要同步的代码是什么呢？ * 把多条语句操作共享数据的代码包起来 * * 注意： * · · 同步可以解决安全问题的根本就在哪个对象上。该对象相当于锁的功能 * 要求多个线程使用同一把锁 */ public class SellTicketDemo { public static void main(String[] args) { SellTicket st=new SellTicket(); Thread t1=new Thread(st,"窗口1"); Thread t2=new Thread(st,"窗口2"); Thread t3=new Thread(st,"窗口3"); t1.start(); t2.start(); t3.start(); } }
标签：
原文地址：http://www.cnblogs.com/aigeileshei/p/5581932.html
