------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------
黑马程序员 java 基础 毕向东 面向对象 多线程
1线程介绍
* 线程是一个执行中的程序* 每一个进程执行都有一个执行顺序，该顺序是一个执行路径
* 或者叫一个控制单元
*
* 线程 才是进程中独立的控制单元
* 线程在控制着进程的执行
* 一个进程中至少有一个线程
*
* java 虚拟机启动时会有一个进程叫做java.ext
* 该进程中至少有一个进程，负责执行
* 这个线程运行的代码存在于main方法中
* 该线程称为主线程
*
* 扩展：更详细是说
* jvm启动不止一个线程，还有垃圾回收机制的线程
2 线程实现 继承Thread
package ThreadH;
/*
* 线程是一个执行中的程序
* 每一个进程执行都有一个执行顺序，该顺序是一个执行路径
* 或者叫一个控制单元
*
* 线程 才是进程中独立的控制单元
* 线程在控制着进程的执行
* 一个进程中至少有一个线程
*
* java 虚拟机启动时会有一个进程叫做java.ext
* 该进程中至少有一个进程，负责执行
* 这个线程运行的代码存在于main方法中
* 该线程称为主线程
*
* 扩展：更详细是说
* jvm启动不止一个线程，还有垃圾回收机制的线程
*
*
* 如何自定义线程呢
* 通过对api查阅，java以及封装了线程这类事物的描述即Thread类
* 继承重新run即可
* 步骤：
* 1：继承Thread
* 2；复写run方法
* 目的：将自定义的代码存储在run方法中，让线程运行
* 3：调用线程的start方法；有俩个作用，1启动线程2调用run方法
* 结果并不相同，而且main和新线程并不是同时执行，
* CPU实际上在线程之间快速切换，cpu 执行到谁，谁运行
* 给人看起来是在同时执行的
* 我们可以形象的多线程的运行行为在互相抢夺CPU的执行权
* 执行多长时间，CPU说了算
*
* 为什么要覆盖run方法呢
* Thread 类用于描述线程。
* 该类就定义了一个功能，用于存储线程要运行的代码，该
* 存储功能就是run方法
* 也就是说 Thread 的run方法 用于存储线程要执行的代码
* 问题来了：
* */
public class ThreadDemo{
public static void main(String args[]) {
Demo d=new Demo();
d.start();
//开启线程并执行该线程的run方法
//d.run();仅仅是对象的调用
for(int i=0;i<100;i++)
System.out.println("main run");
}
}
class Demo extends Thread{
public void run(){
for(int i=0;i<100;i++)
System.out.println("demo run");
}
}
3 线程名字
package ThreadH;
/*
* 线程都有自己默认的名字
*THread-编号 从零开始
*static Thread currenThread（）获取当前线程的对象
*getName（） 获取线程的名称
*setName（） 或者使用构造函数 设置名称*/
public class ThreadTestT{
public static void main(String[] args) {
TestT t=new TestT("t1");
TestT t2=new TestT("t2");
t.start();
t2.start();
for (int i = 0; i < 60; i++) {
System.out.println("main run +"+i);
}
}
}
class TestT extends Thread{
//private String name;
public TestT(String name) {
super(name);
//this.name=name;
}
public void run() {
for (int i = 0; i < 60; i++) {
//System.out.println(name+"test run +"+i);
System.out.println((Thread.currentThread()==this)+this.getName()+"test run +"+i);
}
}
}
4 卖票程序 中 体现Runnable 实现方式 and 实现线程同步 and 线程同步锁 this
package ThreadH;
/*需求：简单的卖票程序
* 多个窗口卖票
* 创建线程的第二中方式：
* 1；定义类实现Runnable接口，
* 2:覆盖Runnable接口中的run方法
* 将线程要运行的代码存放在run方法中
*
* 3：通过Thread类建立线程对象
* 4：将Runnable接口的子类对象作为实际参数传递给Thread类的构造函
* why？因为自定义的 的run方法所属的对象是Runnable接口的子类对象
* 所以要让线程去指定对象的run方法，就必须明确该run方法所属对象
* 5：调用Thread类的start方格，开启线程并执行Runnable中的run方法
*
* 实现方式和继承方式的区别；
*关键的部分：
*避免了单继承的局限性
*建议使用 的多线程实现方式
*
*区别：
*继承Thread线程代码存放在Thread的子类run方法中
*
*实现Runnable 线程代码存放在接口子类的run方法
*
*
*通过分析，发现打印出0 -1 -2 等错票
*多线程的运行出现了安全问题
*
*问题产生的原因：
*当多条语句在操作线程共享数据时，一个线程对多条语句只执行了一部分，还木有执行完，
*另一个线程进入参与执行，导致共享数据 的错误
*
*解决办法：
*对多条操作共享数据 的语句，只能让一个线程执行完，在执行过程中，
*其他线程不可以参与执行
*
*java 对于多线程的安全问题提供了专业的解决方式
*就是同步代码块
*synchronized（对象）{
*需要被同步的代码
*}
*
*对象如同锁，持有锁的线程可以在同步中执行
*没有持有锁 的线程即使获取CPU 的执行权，也进不去，因为没获取锁
*火车上的卫生间------------经典同步
*
*使用同步的前提：
*1：必须有两个或两个以上的线程
*2：必须是多个线程使用同一个锁
*必须保证同步中只有一个线程在运行
*
*好处：解决了多线程的安全问题
*弊端：多个线程每一次都需要判断，消耗了资源，
*
*
**同步函数用的是哪个锁呢？？？
* --------this-----
* 函数需要被对象调用，函数都有所属对象的引用
* 所以同步函数使用的锁是this
*
* 使用该程序进行验证：
* 一个线程在同步代码块中
* 一个线程在同步函数中
* 都在执行卖票动作
* Thread-1shwo sale:0 出现错票
* */
public class TicketThread {
public static void main(String[] args) {
//Ticket ticket1=new Ticket();
//Ticket ticket2=new Ticket();
//Ticket ticket3=new Ticket();
//Ticket ticket4=new Ticket();
//ticket1.start();
//ticket2.start();
//ticket3.start();
//ticket4.start();
//ticket1.start();
//ticket1.start();
//ticket1.start();
//ticket1.start();
Ticket ticket=new Ticket();
//构造方法：解决Thread（Runnable runnable）
Thread t1=new Thread(ticket);
Thread t2=new Thread(ticket);
Thread t3=new Thread(ticket);
Thread t4=new Thread(ticket);
t1.start();
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
ticket.flag=false;
t2.start();
//t3.start();
//t4.start();
}
}
//class Ticket extends Thread{
//private static int tick=100;
//public void run() {
//while(true){
//if(tick>0){
//System.out.println(currentThread().getName()+"sale:"+tick--);
//}
//}
//}
//}
class Ticket implements Runnable{
private static int tick=400;
Object obj=new Object();
boolean flag=true;
public void run() {
if(flag){
while(true){
//synchronized(obj){//同步代码块
synchronized(this){//同步代码块
if(tick>0){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"run sale:"+tick--);
}
}
}
}else{
while(true)
show();
}
}
synchronized void show (){
if(tick>0){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"shwo sale:"+tick--);
}
}
}
//class Ticket implements Runnable{
//private static int tick=400;
//Object obj=new Object();
//public void run() {
//while(true){
//show();
//}
//}
//synchronized void show (){
//if(tick>0){
//try {
//Thread.sleep(10);
//} catch (InterruptedException e) {
//e.printStackTrace();
//}
//System.out.println(Thread.currentThread().getName()+"sale:"+tick--);
//}
//}
//}6
5卖票程序中 静态代码块 同步
package ThreadH;
/*需求：简单的卖票程序
* 多个窗口卖票
* 创建线程的第二中方式：
* 1；定义类实现Runnable接口，
* 2:覆盖Runnable接口中的run方法
* 将线程要运行的代码存放在run方法中
*
* 3：通过Thread类建立线程对象
* 4：将Runnable接口的子类对象作为实际参数传递给Thread类的构造函
* why？因为自定义的 的run方法所属的对象是Runnable接口的子类对象
* 所以要让线程去指定对象的run方法，就必须明确该run方法所属对象
* 5：调用Thread类的start方格，开启线程并执行Runnable中的run方法
*
* 实现方式和继承方式的区别；
*关键的部分：
*避免了单继承的局限性
*建议使用 的多线程实现方式
*
*区别：
*继承Thread线程代码存放在Thread的子类run方法中
*
*实现Runnable 线程代码存放在接口子类的run方法
*
*
*通过分析，发现打印出0 -1 -2 等错票
*多线程的运行出现了安全问题
*
*问题产生的原因：
*当多条语句在操作线程共享数据时，一个线程对多条语句只执行了一部分，还木有执行完，
*另一个线程进入参与执行，导致共享数据 的错误
*
*解决办法：
*对多条操作共享数据 的语句，只能让一个线程执行完，在执行过程中，
*其他线程不可以参与执行
*
*java 对于多线程的安全问题提供了专业的解决方式
*就是同步代码块
*synchronized（对象）{
*需要被同步的代码
*}
*
*对象如同锁，持有锁的线程可以在同步中执行
*没有持有锁 的线程即使获取CPU 的执行权，也进不去，因为没获取锁
*火车上的卫生间------------经典同步
*
*使用同步的前提：
*1：必须有两个或两个以上的线程
*2：必须是多个线程使用同一个锁
*必须保证同步中只有一个线程在运行
*
*好处：解决了多线程的安全问题
*弊端：多个线程每一次都需要判断，消耗了资源，
*
*
**同步函数用的是哪个锁呢？？？
* --------this-----
* 函数需要被对象调用，函数都有所属对象的引用
* 所以同步函数使用的锁是this
*
* 使用该程序进行验证：
* 一个线程在同步代码块中
* 一个线程在同步函数中
* 都在执行卖票动作
* Thread-1shwo sale:0 出现错票
* */
public class StaticTicketThread {
public static void main(String[] args) {
//Ticket ticket1=new Ticket();
//Ticket ticket2=new Ticket();
//Ticket ticket3=new Ticket();
//Ticket ticket4=new Ticket();
//ticket1.start();
//ticket2.start();
//ticket3.start();
//ticket4.start();
//ticket1.start();
//ticket1.start();
//ticket1.start();
//ticket1.start();
TicketSta ticket=new TicketSta();
//构造方法：解决Thread（Runnable runnable）
Thread t1=new Thread(ticket);
Thread t2=new Thread(ticket);
Thread t3=new Thread(ticket);
Thread t4=new Thread(ticket);
t1.start();
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
ticket.flag=false;
t2.start();
//t3.start();
//t4.start();
}
}
//class Ticket extends Thread{
//private static int tick=100;
//public void run() {
//while(true){
//if(tick>0){
//System.out.println(currentThread().getName()+"sale:"+tick--);
//}
//}
//}
//}
class TicketSta implements Runnable{
private static int tick=400;
Object obj=new Object();
boolean flag=true;
public void run() {
if(flag){
while(true){
//synchronized(obj){//同步代码块
//synchronized(this){//同步代码块
synchronized(TicketSta.class){//同步代码块
if(tick>0){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"run sale:"+tick--);
}
}
}
}else{
while(true)
show();
}
}
//static synchronized void show (){
//如果是静态方法，使用的锁不再是this，因为静态方法不可以定义this
//类进入内存，生成对应类的字节码对象
//静态进内存，内存中没有本类对象，但一定有该类对应的字节码文件对象
//类名.class 该对象的类型是Class
//静态的同步方法，使用的锁是该方法所在类的字节码文件对象，类名.class 在内存中唯一
static synchronized void show (){
if(tick>0){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"shwo sale:"+tick--);
}
}
}
//class Ticket implements Runnable{
//private static int tick=400;
//Object obj=new Object();
//public void run() {
//while(true){
//show();
//}
//}
//synchronized void show (){
//if(tick>0){
//try {
//Thread.sleep(10);
//} catch (InterruptedException e) {
//e.printStackTrace();
//}
//System.out.println(Thread.currentThread().getName()+"sale:"+tick--);
//}
//}
//}
6银行程序 模拟多线程 操作
package ThreadH;
import sun.launcher.resources.launcher;
/*
*银行有一个金库
*有两个储户，分别存300员，每次存100，存3次
*目的：该程序是否有安全问题？
*如果有，如何解决
*如何找到问题：
*1：明确哪些代码是多线程运行代码
*for (int i = 0; i < 3; i++) {
bank.add(100);
}
*2：明确共享数据 private int sum;
private Bank bank=new Bank();
*3：明确多线程运行代码中是操作共享数据的
*
sum+=n;
System.out.println("sum="+sum);
*
*
*同步的两种表现形式
*1：同步代码块 synchronized（Object o） { 同步代码}
*2：同步函数 将 synchronized 作为函数的修饰符
*
*
*同步函数用的是哪个锁呢？？？
* --------this-----
* 函数需要被对象调用，函数都有所属对象的引用
* 所以同步函数使用的锁是this
* */
public class BankDemo {
public static void main(String[] args) {
Cus cus=new Cus();
Thread thread1=new Thread(cus);
Thread thread2=new Thread(cus);
thread1.start();
thread2.start();
}
}
class Bank{
private int sum;
//public void add(int n) {
//synchronized (this) {
//sum+=n;
//try {
//Thread.sleep(10);
//} catch (InterruptedException e) {
//e.printStackTrace();
//}
//System.out.println("sum="+sum);
//}
//
//}
public synchronized void add(int n) {
//synchronized (this) {
sum+=n;
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("sum="+sum);
//}
}
}
class Cus implements Runnable{
private Bank bank=new Bank();
public void run() {
for (int i = 0; i < 3; i++) {
bank.add(100);
}
}
}
7单例模式中多线程 的使用 饿汉式 懒汉式
package ThreadH;
/*
* 单例设计模式
*
* 1：饿汉式
* 2：懒汉式
* -------------------------------------------------------
* 饿汉式：
* class ClassA {
* private static final ClassA c=new ClassA（）;
* private ClassA（）{
* }
* public static ClassA getInstance（）{
* return c;
* }
* }
*
* -------------------------------------------------------
* 懒汉式
* class ClassA {
* private static ClassA c=null;
* private ClassA（）{
* }
* public static ClassA getInstance（）{
* if（c==null）{
* c=new ClassA();
* 为空才实例化对象，所以叫做懒懒
* 也教师延迟加载，对象被延迟了
* }
* return c;
* }
* }
*
* 懒汉式与饿汉式的区别：
*
* */
public class SingleDemo {
public static void main(String[] args) {
}
}
class Single {
private static Single c=null;
private Single(){
}
public static Single getInstance(){
// public static synchronized Single getInstance(){
//虽然可以解决同步问题，但会低效
//用双重判断可以提高效率
/*
* 分析执行过程
* Thread 1执行到if(c==null)为真，
* 执行synchronized (Single.class) {}
* 获取了锁，其他线程可以可以执行到该行之前，但会在此次等待
* Thread 判断if(c==null) 为真，实例化 c
* 执行完同步代码块后退出，其他线程进入同步代码块，
* 执行if(c==null) 为假，退出
* 当以后的线程在实例化时，第一行的if(c==null)判断不通过
* 就不会再执行同步代码块
*
* 在以后的实例化过程中提高了下效率
*
* 最好是选择是使用饿汉式
* */
if(c==null){
synchronized (Single.class) {
if(c==null){
c=new Single();
}
}
}
return c;
}
}
8思索死锁
例子1
package ThreadH;
/*思索死锁
* 例如筷子
*
* 同步中嵌套同步
* */
public class DeadLockTicketThread {
public static void main(String[] args) {
TicketDead ticket=new TicketDead();
//构造方法：解决Thread（Runnable runnable）
Thread t1=new Thread(ticket);
Thread t2=new Thread(ticket);
t1.start();
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
ticket.flag=false;
t2.start();
}
}
class TicketDead implements Runnable{
private static int tick=1000;
Object obj=new Object();
boolean flag=true;
public void run() {
if(flag){
while(true){
synchronized(obj){//同步代码块
show();
}
}
}else{
while(true)
show();
}
}
synchronized void show (){
synchronized(obj){//同步代码块
if(tick>0){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"run sale:"+tick--);
}
}
}
}
//}
例子2
package ThreadH;
public class DeadLockTest{
public static void main(String args[]) {
Thread thread1=new Thread(new TestDe(true));
Thread thread2=new Thread(new TestDe(false));
thread1.start();
thread2.start();
}
}
class TestDe implements Runnable {
private boolean flag;
public TestDe(boolean flag) {
this.flag= flag;
}
@Override
public void run() {
if (flag) {
while(true){
synchronized (MyLock.locka) {
System.out.println("if locka");
synchronized (MyLock.lockb) {
System.out.println("else lockb");
}
}
}
}else {
while(true){
synchronized (MyLock.lockb) {
System.out.println("else lockb");
synchronized (MyLock.locka) {
System.out.println("else locka");
}
}
}//while
}
}
}
class MyLock{
static Object locka=new Object();
static Object lockb=new Object();
}