day 15
线程
-
并发与并行
- 并发：指两个或多个事件在同一个时间段内发生
- 并行：指两个或多个事件在同一时刻发生（同时发生）
-
线程与进程
- 进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程，进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序是一个进程从创建，运行到消亡的过程
- 线程：线程是进程中的一个 执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序可以称之为多线程
- 简而言之，一个程序运行后至少有一个进程，一个进程中可以包含多个线程
-
线程调度
- 分时调度：所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间
- 抢占式调度：优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个***（Java使用的是抢占式调度）***
-
创建线程类
- Thread代表线程，所有的线程对象都必须是Thread类或其子类的实例，每个线程的作用是完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。
-
定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务，因此把run()方法称为线程执行体
-
创建Thread子类的实例，即创建了线程对象
-
调用线程对象的start（）方法来启动该线程
public class Demo01{ public static void main(String[] args){ MyThread mt = new MyThread("新的线程");//创建自定义线程对象 mt.start;//开启新线程 for(int i = 0; i < 10 ;i+){ System.out.println("main线程"+i);//在主方法中执行for循环 } } }public class MyThread extends Thread{ public MyThread(String name){//定义指定线程名称的构造方法 super(name);//调用父类的String参数的构造方法，指定线程的名称 } @Override public void run(){ for(int i=0;i<10;i++){ System.out.pring(getName()+":正在执行！"+i); } } }
-
- Thread代表线程，所有的线程对象都必须是Thread类或其子类的实例，每个线程的作用是完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。
-
多线程原理
- 程序启动运行main的时候，Java虚拟机启动一个进程，主线程main在main（）掉哦那个时被创建。随着调用mt的对象的start方法，另外一个新的线程也启动了，这样，整个应用就在多线程下运行
-
Thread类
- 构造方法
- public Thread()：分配一个新的线程对象
- public Thread(String name)：分配一个指定名字的新的线程对象
- public Thread(Runnable target)：分配一个带有指定目标新的线程对象
- public Thread(Runnable target,String name)：分配一个带有指定目标新的线程对象并指定名字
- 常用方法
- public String Getname()：获取当前线程名称
- public void start()：导致此线程开始执行，Java虚拟机调用此线程的run方法
- public static void sleep(long millis)：此线程要执行的任务在此处定义代码
- public static Thread currentThread()：返回当前正在执行的线程对象的引用
- 构造方法
-
创建线程方式二
-
步骤
-
定义Runnable接口的实现类，并重写该接口的run（）方法，该run（）方法的方法体同样是该线程的线程执行体
-
创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象
-
调用线程对象的start方法来启动线程
public class Myrunnable implements Runnable{ @Override public void run(){ for(int i=0;i < 20;i++){ System.out.println(Thread.currentThread().getName()+""+i) } } }public calss Demo{ public static void main(String [] args){ Myrunnable mr=new MyRunnable();//创建自定义类对象，线程任务对象 Thread t= new Thread(mr,"小强");//创建线程对象 t.start(); for(int i =0 ;i< 20;i++){ System.out.ptintln("旺财"+i); } } }
-
-
-
Thread和Runnable的区别
- 如果一个类继承Thread，则不适合资源共享。但是如果实现了Runnable接口的话，则很容易实现资源共享
- 实现runnable接口比继承Thread类所具有的优势：
- 适合多个相同的程序代码的线程去共享同一个资源
- 可以避免Java中的单继承的局限性
- 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立
- 线程池只能放入Runnable或Callable类线程，不能直接放入继承Thread的类
-
匿名内部类方式实现线程的创建
-
使用线程内的匿名内部类方式，可以方便的实现每个线程执行不同的线程任务操作
-
使用匿名内部类的方式实现Runnable接口，重新Runnable接口中的run方法：
public class NonameInnerClassThread{ public static void main(){ new Tread(new Runnable(){ @Override public void run(){ for(int i=0;i<20;i++){ System.out.println("张宇："+i); } } }).start(); for(int i= 0;i<20;i++){ System.out.println("费玉清"+i); } } }
-
线程安全
-
概念
-
如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的
-
模拟卖票
package cn.javase.day15.sellticket; public class Ticket implements Runnable{ private int ticket = 100; @Override public void run() { while(true){//每个窗口永远开启卖票操作 if(ticket>0){//有票可以卖 try { Thread.sleep(100);//模拟出票时间 } catch (InterruptedException e) { e.printStackTrace(); } String name = Thread.currentThread().getName(); System.out.println(name+"正在卖，剩余票："+--ticket);//卖出一份，并减少数量 } else { break;//小于零则退出程序 } } } }package cn.javase.day15.sellticket; public class TicketTest { public static void main(String[] args) { Ticket ticket=new Ticket(); Thread t1=new Thread(ticket,"窗口1"); Thread t2=new Thread(ticket,"窗口2"); Thread t3=new Thread(ticket,"窗口3"); t1.start(); t2.start(); t3.start(); } } 结果： 。 。 。 窗口3正在卖，剩余票：4 窗口2正在卖，剩余票：3 窗口1正在卖，剩余票：3 窗口3正在卖，剩余票：2 窗口2正在卖，剩余票：1 窗口1正在卖，剩余票：1 窗口3正在卖，剩余票：0 窗口1正在卖，剩余票：-1 窗口2正在卖，剩余票：-2发现程序出现了两个问题：
-
相同的票数,比如3这张票被卖了两回。
-
不存在的票，比如0票与-1，-2票，是不存在的。
这种问题，几个窗口(线程)票数不同步了，这种问题称为线程不安全。
-
-
-
线程安全
- 概念
- 当我们使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题
- 要解决上述多线程并发访问一个资源的安全性问题：也就是解决重复票与不存在票问题，Java中提供了同步机制synchronized来解决
- 窗口1线程进入操作的时候，窗口2和窗口3线程只能在外等着，窗口1操作结束，窗口1和窗口2和窗口3才有机会进入代码去执行。也就是说在某个线程修改共享资源的时候，其他线程不能修改该资源，等待修改完毕同步之后，才能去抢夺CPU 资源，完成对应的操作，保证了数据的同步性，解决了线程不安全的现象。
- 概念
-
同步代码块
-
同步代码块：synchronized关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问
-
格式
synchronized(同步锁){ 需要同步操作的代码 } -
同步锁：对象的同步锁只是一个概念，可以想象为在对象上标记了一个锁
-
锁对象可以是任意类型
-
多个线程对象要使用同一把锁
-
注意：在任何时候，最多允许一个线程拥有同步锁，谁拿到锁就进入代码块，其他的线程只能在外等着
-
举例
package cn.javase.day15.sellticket; public class Ticket implements Runnable{ private int ticket = 100; Object lock = new Object(); @Override public void run() { while(true){ synchronized (lock){ if(ticket>0){ try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } String name = Thread.currentThread().getName(); System.out.println(name+"正在卖，剩余票："+(--ticket)); } else { break; } } } } } Test类同上 结果 窗口3正在卖，剩余票：20 窗口3正在卖，剩余票：19 窗口1正在卖，剩余票：18 窗口1正在卖，剩余票：17 窗口1正在卖，剩余票：16 窗口1正在卖，剩余票：15 窗口3正在卖，剩余票：14 窗口2正在卖，剩余票：13 窗口2正在卖，剩余票：12 窗口3正在卖，剩余票：11 窗口1正在卖，剩余票：10 窗口1正在卖，剩余票：9 窗口3正在卖，剩余票：8 窗口3正在卖，剩余票：7 窗口3正在卖，剩余票：6 窗口2正在卖，剩余票：5 窗口2正在卖，剩余票：4 窗口3正在卖，剩余票：3 窗口1正在卖，剩余票：2 窗口3正在卖，剩余票：1 窗口3正在卖，剩余票：0当使用了同步代码块后，上述线程的安全问题解决了
-
-
-
同步方法
-
使用synchronized修饰方法，就叫做同步方法，保证A线程执行该方法的时候，其他线程只能在方法外等着
-
格式：
public synchronized void method(){ 可能产生线程安全问题的代码 } -
使用同步方法代码
package cn.javase.day15.sellticket; public class Ticket implements Runnable{ private int ticket = 100; public synchronized boolean sellticket() { if (ticket > 0) { try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "正在卖，剩余票：" + (--ticket)); return true; } else return false; } @Override public void run() { while (true){ if (sellticket()) {//如果为真继续卖票 } else break;//为假就停止卖票 } } } Test类同上 结果 。 。 。 窗口3正在卖，剩余票：21 窗口3正在卖，剩余票：20 窗口3正在卖，剩余票：19 窗口3正在卖，剩余票：18 窗口3正在卖，剩余票：17 窗口3正在卖，剩余票：16 窗口1正在卖，剩余票：15 窗口3正在卖，剩余票：14 窗口2正在卖，剩余票：13 窗口2正在卖，剩余票：12 窗口2正在卖，剩余票：11 窗口2正在卖，剩余票：10 窗口2正在卖，剩余票：9 窗口2正在卖，剩余票：8 窗口2正在卖，剩余票：7 窗口2正在卖，剩余票：6 窗口2正在卖，剩余票：5 窗口2正在卖，剩余票：4 窗口2正在卖，剩余票：3 窗口3正在卖，剩余票：2 窗口3正在卖，剩余票：1 窗口3正在卖，剩余票：0
-
-
Lock锁
-
Java提供了比synchronized代码块和synchronized方法更广泛的锁定操作，同步代码块/同步方法具有的功能Lock都有，除此之外更强大，更体现面向对象
-
Lock锁也称同步锁，加锁与释放锁方法化
-
public void lock()：加同步锁
-
public void unlock()：释放同步锁
package cn.javase.day15.sellticket; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class Ticket implements Runnable{ private int ticket = 100; Lock lock = new ReentrantLock(); @Override public void run() { while (true){ lock.lock(); if(ticket>0){ try { Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "正在卖，剩余票：" + (--ticket)); }else break; lock.unlock(); } } } Test类同上 结果 窗口3正在卖，剩余票：15 窗口3正在卖，剩余票：14 窗口1正在卖，剩余票：13 窗口1正在卖，剩余票：12 窗口2正在卖，剩余票：11 窗口2正在卖，剩余票：10 窗口2正在卖，剩余票：9 窗口2正在卖，剩余票：8 窗口2正在卖，剩余票：7 窗口2正在卖，剩余票：6 窗口2正在卖，剩余票：5 窗口3正在卖，剩余票：4 窗口1正在卖，剩余票：3 窗口1正在卖，剩余票：2 窗口1正在卖，剩余票：1 窗口1正在卖，剩余票：0
-
-
线程状态
-
当线程当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态
线程状态 导致状态发生条件 New（新建） 线程刚被创建，但是并未启动。还没调用start方法 Runnable（可允许） 线程可以在Java虚拟机中允许的状态，可能正在运行自己代码，也可能没有，这取决于操作系统处理器 Blocked（锁阻塞） 当一个线程试图获取一个对象锁，而该对象锁其他的线程持有，则该线程进入Blocked状态，当该线程持有锁时，该线程将变成Runnable状态 Waiting（无限等待） 一个线程在等待另一个线程执行一个动作，该线程进入Waiting状态。进入这个状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能唤醒 Timed Waiting（计时等待 同Waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。这一状态将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep,Object.wait Teminated(被终止) 因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡 我们不需要去研究这几种状态的实现原理，我们只需知道在做线程操作中存在这样的状态。那我们怎么去理解这几 个状态呢，新建与被终止还是很容易理解的，我们就研究一下线程从Runnable（可运行）状态与非运行状态之间 的转换问题
-
Timed Waiting（计时等待）
-
概念：在我们写卖票的案例中，为了减少线程执行太快，现象不明显等问题，我们在run方法中添加了sleep语句，这样就强制当前正在执行的线程休眠（暂停执行），以减慢线程
-
实现一个计数器，计数到100，在每个数字之间暂停1秒，每隔10个数字输出一个字符串
package cn.javase.day15; public class PrintNumber implements Runnable{ @Override public void run() { for (int i = 0; i <100 ; i++) { if(i%10==0){ System.out.println("---------"); } System.out.println(i); try { Thread.sleep(500); System.out.println("睡眠0.5秒"); } catch (InterruptedException e) { e.printStackTrace(); } } } public static void main(String[] args) { new Thread(new PrintNumber()).start(); } } 结果 1 睡眠0.5秒 2 睡眠0.5秒 3 睡眠0.5秒 4 睡眠0.5秒 5 睡眠0.5秒 6 睡眠0.5秒 7 睡眠0.5秒 8 睡眠0.5秒 9 睡眠0.5秒 10 --------- 睡眠0.5秒 11 睡眠0.5秒 12 睡眠0.5秒 13 睡眠0.5秒 14 睡眠0.5秒 15-
进入 TIMED_WAITING 状态的一种常见情形是调用的 sleep 方法，单独的线程也可以调用，不一定非要有协作关系。
-
为了让其他线程有机会执行，可以将Thread.sleep()的调用放线程run()之内。这样才能保证该线程执行过程中会睡眠
-
sleep与锁无关，线程睡眠到期自动苏醒，并返回到Runnable（可运行）状态。
-
-
-
Waiting（无限等待)
-
一个正在无限期等待另一个线程执行一个特别的（唤醒）动作的线程处于这一状态
package cn.javase.day15; public class WantingTest { public static Object obj=new Object(); public static void main(String [] args){ new Thread(new Runnable() { @Override public void run() { while (true){ synchronized (obj){ System.out.println(Thread.currentThread().getName() +"===获取到锁对象，调用wait方法，进入wait状态，释放锁对象"); try { obj.wait(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+ "===从wait状态醒来，获取到锁对象，继续执行了"); } } } }).start(); new Thread(new Runnable() { @Override public void run() { while (true){ synchronized (obj){ try { System.out.println(Thread.currentThread().getName()+"-----等待10秒钟"); Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+ "-----获取到锁对象，调用notify方法，释放锁对象"); obj.notify(); } } } }).start(); } } 结果 Thread-0===获取到锁对象，调用wait方法，进入wait状态，释放锁对象 Thread-1-----等待10秒钟 Thread-1-----获取到锁对象，调用notify方法，释放锁对象 Thread-0===从wait状态醒来，获取到锁对象，继续执行了 Thread-1-----等待10秒钟 Thread-1-----获取到锁对象，调用notify方法，释放锁对象 Thread-0===获取到锁对象，调用wait方法，进入wait状态，释放锁对象 Thread-1-----等待10秒钟 Thread-1-----获取到锁对象，调用notify方法，释放锁对象 Thread-1-----等待10秒钟 Thread-1-----获取到锁对象，调用notify方法，释放锁对象 Thread-0===从wait状态醒来，获取到锁对象，继续执行了 Thread-0===获取到锁对象，调用wait方法，进入wait状态，释放锁对象 Thread-1-----等待10秒钟 Thread-1-----获取到锁对象，调用notify方法，释放锁对象 Thread-0===从wait状态醒来，获取到锁对象，继续执行了 Thread-0===获取到锁对象，调用wait方法，进入wait状态，释放锁对象 Thread-1-----等待10秒钟 。 。 。通过上述案例我们会发现，一个调用了某个对象的 Object.wait 方法的线程会等待另一个线程调用此对象的Object.notify()方法 或 Object.notifyAll()方法。
其实waiting状态并不是一个线程的操作，它体现的是多个线程间的通信，可以理解为多个线程之间的协作关系， 多个线程会争取锁，同时相互之间又存在协作关系。就好比在公司里你和你的同事们，你们可能存在晋升时的竞 争，但更多时候你们更多是一起合作以完成某些任务。
-
扫一扫
266
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
