java基础--多线程
来源:互联网 发布:知秋凤凰婚庆好不好 编辑:程序博客网 时间:2024/05/18 03:53
一、基本概念:
1. 进程:是一个正在执行中的程序。
每一个进程执行都有一个执行顺序。该顺序是一个执行路径,或者叫一个控制单元。
线程:就是进程中的一个独立的控制单元。线程在控制着进程的执行。
一个进程中至少有一个线程。
2. Java VM 启动的时候会有一个进程java.exe.
该进程中至少一个线程负责java程序的执行。而且这个线程运行的代码存在于main方法中,该线程称之为主线程。
3. 扩展:其实更细节说明jvm,jvm启动不止一个线程,还有负责垃圾回收机制的线程。
4. 线程运行的5种状态:
被创建
运行(既有运行资格,又有执行权)
阻塞\临时状态(具备运行资格,但没有执行权,等待cpu执行权)
冻结(sleep、wait等待notify,没有执行资格)
消亡(采取stop( ) 强行结束 或者run方法运行结束)
二、 创建线程的第一种方式:继承Thread类
1 、创建步骤:
1> 定义类继承Thread。
2> 复写Thread类中的run方法。
目的:将自定义代码存储在run方法。让线程运行。
3> 调用线程的start方法,
该方法两个作用:启动线程,调用run方法。
2、 线程的执行:
因为多个线程都获取cpu的执行权。cpu执行到谁,谁就运行。
明确一点,在某一个时刻,只能有一个程序在运行。(多核除外)
cpu在做着快速的切换,以达到看上去是同时运行的效果。
我们可以形象把多线程的运行行为在互相抢夺cpu的执行权。
这就是多线程的一个特性:随机性。谁抢到谁执行,至于执行多长,cpu说的算。
3.、为什么要覆盖run方法呢?
Thread类用于描述线程。
该类就定义了一个功能,用于存储线程要运行的代码,该存储功能就是run方法。
也就是说Thread类中的run方法,用于存储线程要运行的代码。
4、获取线程
static ThreadcurrentThread():获取当前线程对象。
getName(): 获取线程名称。
设置线程名称:setName或者构造函数。
继承方式创建线程示例代码:
class Test extends Thread {// private String name;Test(String name) {// this.name = name;super(name);//调用父类的构造方法去初始化名称}//覆盖run方法,定义要运行的代码public void run() {for (int x = 0; x < 60; x++) {System.out.println((Thread.currentThread() == this) + "..."+ this.getName() + " run..." + x);}}}class ThreadTest {public static void main(String[] args) {Test t1 = new Test("one---");//创建线程,并初始化线程名称Test t2 = new Test("two+++");t1.start();//开启线程并执行线程的run方法t2.start();// t1.run();//仅仅是对象调用方法,虽然线程创建了,但并没有开启线程,// t2.run();for (int x = 0; x < 60; x++) {System.out.println("main....." + x);}}}
多线程示例代码:简单的卖票程序
说明:这个示例从另一方面说明了继承方式实现多线程的局限性,
因为不能够实现多个线程共享一份数据。
如果使用静态,可以解决,但由于生存周期太长,也不能从根本上解决问题,所以这种方式产生的多线程不能满足要求
class Ticket extends Thread{private int tick = 100;//使用静态,生存周期太长,也不能从根本上解决问题//private static int tick = 100;public void run(){while(true){if(tick>0){System.out.println(Thread.currentThread().getName()+"....sale : "+ tick--);}}}}class TicketDemo{public static void main(String[] args) {Ticket t = new Ticket();Thread t1 = new Thread();//创建了一个线程;//Thread t2 = new Thread();//创建了一个线程;//Thread t3 = new Thread();//创建了一个线程;//Thread t4 = new Thread();//创建了一个线程;t1.start();//已经启动的线程再次启动,出现线程状态异常t2.start();t3.start();t4.start();/*每个线程拥有自己的tick变量,不是同一份数据Ticket t1 = new Ticket();//Ticket t2 = new Ticket();//Ticket t3 = new Ticket();//Ticket t4 = new Ticket();t1.start();t1.start();t1.start();t1.start();*/}}
三、第二种方式:实现Runable接口
由来:如果自定义的类中有多线程要运行的代码。但是该类有自己的父类。
那么就不可以再继承Thread,因为java中不支持多继承。
1. 创建步骤:
1>定义类实现Runnable接口
2>覆盖Runnable接口中的run方法。将线程要运行的代码存放在该run方法中。
3>通过Thread类建立线程对象。
4>将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
因为,自定义的run方法所属的对象是Runnable接口的子类对象。
所以要让线程去指定指定对象的run方法。就必须明确该run方法所属对象
5> 调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。
2. 实现方式和继承方式的区别
1>实现方式好处:避免了单继承的局限性。
如果自定义的类中有多线程要运行的代码,但是该类有自己的父类。
那么就不可以再继承Thread,因为java中不支持多继承。
2> 继承Thread:线程代码存放Thread子类run方法中。
实现Runnable,线程代码存在接口的子类的run方法。
四 、多线程的安全问题
1、问题的原因:
1> 多线程代码中有操作共享数据。
2> 多条语句操作该共享数据。
当具备两个关键点时,有一个线程对多条操作共享数据的代码执行的一部分。还没有执行完,
另一个线程开始参与执行,就会发生数据错误。
2、 解决办法:
对多条操作共享数据的语句,只能让一个线程都执行完。在执行过程中,其他线程不可以参与执行。
Java对于多线程的安全问题提供了专业的解决方式。
就是同步代码块。
synchronized(对象)
{
需要被同步的代码
}
对象如同锁。持有锁的线程可以在同步中执行。
没有持有锁的线程即使获取cpu的执行权,也进不去,因为没有获取锁。
3、同步的表现形式:
1> 同步代码块。
2> 同步函数。
两者有什么不同:
同步代码块使用的锁是任意对象。
同步函数使用的锁是this。
4.、同步的前提:
1> 必须要有两个或者两个以上的线程。
2> 必须是多个线程使用同一个锁。
必须保证同步中只能有一个线程在运行。
5、同步的利弊:
好处:解决了多线程的安全问题。
弊端:多个线程需要判断锁,较为消耗资源,
6.、如何找线程安全问题:
1>明确哪些代码是多线程运行代码。
2>明确共享数据。
3>明确多线程运行代码中哪些语句是操作共享数据的。
实现Runnable方式的安全多线程售票演示代码:
class Ticket implements Runnable{private int tick = 1000;Object obj = new Object();public void run(){while(true){synchronized(obj){if(tick>0){//只能try,因为run是复写了Runnable接口的run,接口的run没有抛//try{Thread.sleep(10);}catch(Exception e){}System.out.println(Thread.currentThread().getName()+"....sale : "+ tick--);}}}}}class TicketDemo2{public static void main(String[] args) {//只建立了一个Ticket对象,内存中只有一个tick成员变量,所以是共享数据Ticket t = new Ticket();Thread t1 = new Thread(t);Thread t2 = new Thread(t);Thread t3 = new Thread(t);Thread t4 = new Thread(t);t1.start();t2.start();t3.start();t4.start();}
五、 函数对应的锁
1、同步函数用的是哪一个锁呢?
函数需要被对象调用。那么函数都有一个所属对象引用。就是this。
所以同步函数使用的锁是this。
2、如果同步函数被静态修饰后,使用的锁是什么呢?
通过验证,发现不在是this。因为静态方法中也可以定义this。
静态进内存是,内存中没有本类对象,但是一定有该类对应的字节码文件对象。
类名.class 该对象的类型是Class
静态的同步方法,使用的锁是该方法所在类的字节码文件对象,类名.class
六 单列模式:懒汉式的线程安全问题
//懒汉式:多线程访问时,会出现安全问题(重点)class Single{private static Single s = null;private Single(){}public static Single getInstance(){if(s==null) {/ /使用双重判断,提高效率synchronized(Single.class)//每次都判断锁,比较低效{if(s==null)//会出现线程安全问题//--->A;s = new Single();}}return s;}}
七、死锁
出现原因:同步中嵌套同步,锁却不同
死锁示例演示代码:
class DeadLockTest implements Runnable {private boolean flag;DeadLockTest(boolean flag) {this.flag = flag;}@Overridepublic void run() {// TODO Auto-generated method stubif (flag) {while (true) {synchronized (Lock.locka) {System.out.println(Thread.currentThread().getName()+ " if locka");synchronized (Lock.lockb) {System.out.println(Thread.currentThread().getName()+ " if lockb");}}}}else {while (true) {synchronized (Lock.lockb) {System.out.println(Thread.currentThread().getName()+ " else lockb");synchronized (Lock.locka) {System.out.println(Thread.currentThread().getName()+ " else locka");}}}}}}class Lock {public static Object locka = new Object();public static Object lockb = new Object();}public class DeadLock {public static void main(String[] args) {// TODO Auto-generated method stubDeadLockTest t1 = new DeadLockTest(true);DeadLockTest t2 = new DeadLockTest(false);Thread a = new Thread(t1);Thread b = new Thread(t2);a.start();b.start();}}
八、线程间通讯
多个线程在操作同一个资源,但是操作的动作不同
线程唤醒机制中操作线程的方法:wait;notify(); notifyAll();
1、操作线程的方法使用在哪里?
都使用在同步中,因为要对持有监视器(锁)的线程操作。
所以要使用在同步中,因为只有同步才具有锁。
2、为什么这些操作线程的方法要定义Object类中呢?
因为这些方法在操作同步中线程时,都必须要标识它们所操作线程持有的锁,
只有同一个锁上的被等待线程,可以被同一个锁上notify唤醒。
不可以对不同锁中的线程进行唤醒。也就是说,等待和唤醒必须是同一个锁。
而锁可以是任意对象,所以可以被任意对象调用的方法定义Object类中。
多个生产者和消费者示例代码:
说明:
对于多个生产者和消费者,要使用while循环和notifyAll()
1、为什么要使用while判断标记?
原因:让被唤醒的线程再一次判断标记,避免直接向下执行,多次生产,却消费一次
2。、为什么要要使用notifyAll?
因为需要唤醒对方线程,如果只用notify,容易出现只唤醒本方线程的情况。导致程序中的所有线程都等待。
class Resource{private String name;private int count = 1;private boolean flag = false;// t1 t2public synchronized void set(String name){while(flag)//这里使用while,使线程每次被唤醒都判断标记,以免唤醒本方时, //由于没有判断标记,而多次生产try{this.wait();}catch(Exception e){}//t1(放弃资格) t2(获取资格)this.name = name+"--"+count++;System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);flag = true;this.notifyAll();//为了避免唤醒时,只唤醒了本方,在返回去判断时导致死锁,所以采用全部唤醒, //又因为要循环判断标记,所以不会出现生产多次消费一次的情况}// t3 t4 public synchronized void out(){while(!flag)try{wait();}catch(Exception e){}//t3(放弃资格) t4(放弃资格)System.out.println(Thread.currentThread().getName()+"...消费者........."+this.name);flag = false;this.notifyAll();}}class Producer implements Runnable{private Resource res;Producer(Resource res){this.res = res;}public void run(){while(true){res.set("+商品+");}}}class Consumer implements Runnable{private Resource res;Consumer(Resource res){this.res = res;}public void run(){while(true){res.out();}}}class ProducerConsumerDemo {public static void main(String[] args) {Resource r = new Resource();Producer pro = new Producer(r);Consumer con = new Consumer(r);Thread t1 = new Thread(pro);Thread t2 = new Thread(pro);Thread t3 = new Thread(con);Thread t4 = new Thread(con);t1.start();t2.start();t3.start();t4.start();}}
九、 JDK1.5 中提供了多线程升级解决方案
将同步Synchronized替换成现实Lock操作。
将Object中的wait,notify notifyAll,替换了Condition对象。
该对象可以Lock锁 进行获取。
该示例中,实现了本方只唤醒对方操作。
Lock:替代了Synchronized
方法:
lock
unlock
newCondition()
Condition:替代了Object 、wait、 notify、 notifyAll
方法:
await();
signal();
signalAll();importjava.util.concurrent.locks.*;
使用Lock与Condition的多个生产者与消费者示例代码:
该示例中,实现了本方只唤醒对方操作
import java.util.concurrent.locks.Condition;import java.util.concurrent.locks.ReentrantLock;class Resource {private String name;private int count = 1;private boolean flag = false;// t1 t2private ReentrantLock lock = new ReentrantLock();// 创建两个condition对象,以便控制只唤醒对方private Condition condition_pro = lock.newCondition();private Condition condition_con = lock.newCondition();public void set(String name) throws InterruptedException {lock.lock();try {while (flag)condition_pro.await();// t1,t2this.name = name + "--" + count++;System.out.println(Thread.currentThread().getName() + "...生产者.."+ this.name);flag = true;condition_con.signal();} finally {lock.unlock();// 释放锁的动作一定要执行。}}// t3 t4public void out() throws InterruptedException {lock.lock();try {while (!flag)condition_con.await();System.out.println(Thread.currentThread().getName()+ "...消费者........." + this.name);flag = false;condition_pro.signal();} finally {lock.unlock();}}}class Producer implements Runnable {private Resource res;Producer(Resource res) {this.res = res;}public void run() {while (true) {try {res.set("+商品+");} catch (InterruptedException e) {}}}}class Consumer implements Runnable {private Resource res;Consumer(Resource res) {this.res = res;}public void run() {while (true) {try {res.out();} catch (InterruptedException e) {}}}}class ProducerConsumerDemo2 {public static void main(String[] args) {Resource r = new Resource();Producer pro = new Producer(r);Consumer con = new Consumer(r);Thread t1 = new Thread(pro);Thread t2 = new Thread(pro);Thread t3 = new Thread(con);Thread t4 = new Thread(con);t1.start();t2.start();t3.start();t4.start();}}
八 如何停止线程?
1、只有一种,run方法结束。
开启多线程运行,运行代码通常是循环结构。只要控制住循环,就可以让run方法结,
也就是线程结束。
2、特殊情况:
当线程处于了冻结状态。就不会读取到标记。那么线程就不会结束。
当没有指定的方式让冻结的线程恢复到运行状态是,这时需要对冻结进行清除,
强制让线程恢复到运行状态中来,这样就可以操作标记让线程结束。
3、解决方法
Thread类提供该方法 interrupt(); 需处理异常。在catch语句中对循环条件进行修改,使循环终止。
守护线程:
setDaemon(boolean true)
将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时,Java 虚拟机退出。
该方法必须在启动线程前调用。
在本例中,主线程结束后,剩下的都是守护线程,所以JVM退出,程序结束
停止线程示例演示代码:
public synchronized void run() {while (flag) {try {wait();} catch (InterruptedException e) {System.out.println(Thread.currentThread().getName()+"...Exception");//flag = false;}System.out.println(Thread.currentThread().getName() + "....run");}}public void changeFlag() {flag = false;}}class StopThreadDemo {public static void main(String[] args) {StopThread st = new StopThread();Thread t1 = new Thread(st);Thread t2 = new Thread(st);//t1.setDaemon(true);//t2.setDaemon(true);t1.start();t2.start();int num = 0;while (true) {if (num++ == 60) {//st.changeFlag();t1.interrupt();t2.interrupt();break;}System.out.println(Thread.currentThread().getName() + "......."+ num);}System.out.println("over");}}
join方法
join可以用来临时加入线程执行。
当A线程执行到了B线程的.join()方法时,A就会等待,等B线程都执行完,A才会执行。
如果A执行到了B线程的join方法之前就有线程C在运行时,这时C和B会去争夺CPU执行权,A只有等到B执行完时,才开始执行,和C的状态不相关。
join方法示例代码:
class Demo implements Runnable{public void run(){for(int x=0; x<70; x++){System.out.println(Thread.currentThread().toString()+"....."+x);Thread.yield();}}}class JoinDemo{public static void main(String[] args) throws Exception{Demo d = new Demo();Thread t1 = new Thread(d);Thread t2 = new Thread(d);t1.start();//t1.join();//主线程放弃执行权,等到t1执行完才能继续执行//Thread.sleep(10);让t1获取执行权t2.start();//t1.join();//哪个线程执行这个方法,那个线程就等待t1执行完才执行。for(int x=0; x<80; x++){System.out.println("main....."+x);}System.out.println("over");}}
- Java基础/Java多线程
- Java基础-多线程基础篇
- java多线程基础
- Java多线程编程基础
- java多线程开发基础
- Java多线程基础
- Java -- 多线程技术基础
- 【java】多线程基础
- Java基础:多线程
- Java语言基础:多线程
- Java语言基础:多线程
- Java语言基础:多线程
- java多线程基础分析
- Java多线程编程基础
- java 多线程基础
- Java基础_多线程
- Java多线程基础
- java多线程基础
- 制作一个BCG单文档模拟的对话框
- java线程系列---同步器之CountDownLatch
- C#字符串的各种操作
- 购物车功能分析
- C语言--字符串长度的计算方法
- java基础--多线程
- POJ1191-裸动态规划
- vim学习资料整理
- jni中使用libcurl做网络开发
- 阻止一进入Activity就显示的输入法
- 微软ASP.NET站点部署指南
- 控制台文件管理器vifm
- 关于android的Asset文件夹和画图的一点问题
- 反向代理