java多线程学习笔记

开始时间 2018年8月12日16:39:02

结束时间 2018年8月12日18:41:02

累计时间 2小时

一: 多线程: 

   java : 语法和语句: if while for 
   java: 面向对象: 封装 继承 多态
   IO:   操作文件当中的数据:  File 
       集合: 存放数据: 
   多线程: 合理提高CPU的执行效率。 
   

  概念: 
    进程:正在执行的程序,    其实就是应用程序在在内存当中运行时开辟的一片空间。 
    
   线程: 进程当中的一个执行单元,负责程序的运行。 一个进程当中最少有一条线程。 
   一个进程当中也可以有多条线程, 这个应用程序就称之为多线程。 
   
 并发:如果一个进程当中的多条线程同时执行, 就可以支持为并发。 
 
 多线程的作用:  
   合理的提高CPU的执行效率。  
   
   
二: 主线程的介绍: 
 主线程: JVM 启动后,必然有一个执行路径(线程),从main开始, 一直到主方法
 结束,这个线程称之为主线程: 
 
 
 CPU: 计算机核心:大脑 中央处理器; 
     在某一个时刻,只能运行某个引用程序当中某个线程。  CPU不断的切换执行权限,
     切换的速度非常快,我们用肉眼无法识别。
     
     CPU执行权限的分类:随机的。 不固定。
 
三: 线程的实现方式一: 

   继承: Thread;类: 
   
     重写Run方法:  线程对象要想开启一条线程, start 方法。 
     start 方法会自动调用run方法。
     
     为什么重写run方法? 
     因为Thread类当中提供的run方法,没有实现任何的操作。 返回了
    
  start 方法和  run 方法之间的区别: 
  start方法: 会开启一条新的线程。 
  run方法: 直接调用run方法, 是属于对象的特有的某个方法。 
     
四: 多线程的实现方式二:  
         实现Runnable接口, 重写run方法。 
         
  实现: Runable接口,此时该类不具备线程对象的特点, 
  但是run方法, run方法当中定义的内容,称之为线程任务。 
  
   要想使用对象具备线程特点,需要将线程任务对象作为参数传递给Thread 类。 

  步骤: 
  (1)定义类实现Runnable接口。  避免了单继承的局限。 
  (2)重写run方法。 run定义了线程任务。 同时被执行的代码。 
  (3)创建一个Thread类,然后将Runnable接口的实现类对象作为参数传递。 
  (4)调用start方法, 开启新的线程。 run:
  
  
 五: 面试问题总结: 
 (1)start 方法和 run方法: 
 (2)继承Thread类  或者实现Runnable 接口: 区别
    
    a: 实现Runnable接口,避免了单继承的局限。 
       更加的符合面向对象的特点: 把线程任何和线程对象定义在两个对象当中
       线程任务和线程对象进行了分离。 
       
   b:继承Thread类, 只能单继承。 线程任务和线程对象耦合在一起。  
       创建出来的对象,即封装了线程的任务,又是线程对象。   
       
       建议:使用Runnable方法。   
   
 六:  多线程之间异常机制: 
  
  多条线程之间异常互补干扰。 
  当主线程当中发生了异常,主线程会结束,其他的线程正常运行。 
  当其他的线程当中出现了异常, 对主线程没有影响,主线程正常运行。 
  
  
七: 售票程序: 

         /*       
         100 当第一条线程 获得CPU的执行权, 售票100. 
        Thread-0  97   tickets 已经完成了--操作,但是还没来的急打印,此时cpu的执行权被切走。 
        Thread-0  96   
        Thread-0  95
        Thread-2  98
           
         结果分析: 出现了打印的顺序问题,并不是错误的数据,而是因为,cpu的执行权限随机分配,导致的。 
         
         
         分析最后的结果: 
         Thread-0  0  
        Thread-3  -1
        Thread-2  -2 
        出现了负号票,这就是发生了数据的安全问题。 
         
        多线程出现数据安全的前提 
        (1) 多条线程有共享资源。 
        (2)多条线程多共享的资源进行想过的数学运算。 
         
         
        */ 
    
    
八: 线程的状态:(面试问题)
 (1)新建态:   new Thread(); 
 (2)就绪态: 调用start 方法。 此时线程进入等待队列。 
 (3)运行态: run方法被执行。 
 (4)堵塞/挂起态(冻结): 当程序运行时候,遇到了 sleep wait join yield 等这样的方法。 
 (5)终止态: run方法被执行完毕。  
     
     
九: 解决数据的安全问题: 
  使用同步块,解决数据的安全问题: 
  语法: 
  synchronized(对象){
      被锁的资源。 
  }
  
  对象: 任意对象:
  作用:
          使用同步块解决数据的安全问题; 

 弊端: 降低了程序的性能。 
 
原理:  
  本质上是给共享的资源上了一把锁。 
   当某条线程获得了CPU 并且获得了锁对象, 此时其他的线程没有获得锁对象,
   只能等待。  
   
   
十: 线程同步的一个前提: 
   
   多个线程在同步的时候,必须使用同一把锁。 
   
 当出现了数据安全问题后,加锁。 
 加锁完成后,数据安全的问题并没有得到解决。 
 原因: 多个线程之间并没有使用同一把锁。 
解决: 多个线程之间要想解决数据安全问题,必须使用同一把锁。 
 
 
 
 复习: 
  (1)实现线程的两种方式:  明白:区别; 
  (2)写售票系统。 
    运行结果分析: 
            错误数据的原因:  
            (1)
            (2)
            
     解决:同步块: 前提。同一把锁。 
     

 

/*
 * 创建一个子线程,完成1-100之间自然数的输出。同样地,主线程执行同样的操作
 * 创建多线程的第一种方式:继承java.lang.Thread类
 */
//1.创建一个继承于Thread的子类
class SubThread extends Thread{
	//2.重写Thread类的run()方法.方法内实现此子线程要完成的功能
	public void run(){
		for(int i = 1;i <= 100;i++){
			System.out.println(Thread.currentThread().getName() +":" + i);
		}
	}
}

public class TestThread {
	public static void main(String[] args) {
		//3.创建子类的对象
		SubThread st1 = new SubThread();
		SubThread st2 = new SubThread();

		//4.调用线程的start():启动此线程;调用相应的run()方法
		//一个线程只能够执行一次start()
		//不能通过Thread实现类对象的run()去启动一个线程
		st1.start();
		
		//st.start();
		//st.run();
		st2.start();
		
		for(int i = 1;i <= 100;i++){
			System.out.println(Thread.currentThread().getName() +":" + i);
		}
	}
}
/*
 * Thread的常用方法:
 * 1.start():启动线程并执行相应的run()方法
 * 2.run():子线程要执行的代码放入run()方法中
 * 3.currentThread():静态的,调取当前的线程
 * 4.getName():获取此线程的名字
 * 5.setName():设置此线程的名字
 * 6.yield():调用此方法的线程释放当前CPU的执行权
 * 7.join():在A线程中调用B线程的join()方法,表示:当执行到此方法,A线程停止执行,直至B线程执行完毕,
 * A线程再接着join()之后的代码执行
 * 8.isAlive():判断当前线程是否还存活
 * 9.sleep(long l):显式的让当前线程睡眠l毫秒
 * 10.线程通信:wait()   notify()  notifyAll()
 * 
 * 设置线程的优先级
 * getPriority() :返回线程优先值 
   setPriority(int newPriority) :改变线程的优先级

 */
class SubThread1 extends Thread {
	public void run() {
		for (int i = 1; i <= 100; i++) {
			// try {
			// Thread.currentThread().sleep(1000);
			// } catch (InterruptedException e) {
			// // TODO Auto-generated catch block
			// e.printStackTrace();
			// }
			System.out.println(Thread.currentThread().getName() + ":"
					+ Thread.currentThread().getPriority() + ":" + i);
		}
	}
}

public class TestThread1 {
	public static void main(String[] args) {

		SubThread1 st1 = new SubThread1();
		st1.setName("子线程1");
		st1.setPriority(Thread.MAX_PRIORITY);
		st1.start();
		Thread.currentThread().setName("========主线程");
		for (int i = 1; i <= 100; i++) {
			System.out.println(Thread.currentThread().getName() + ":"
					+ Thread.currentThread().getPriority() + ":" + i);
			// if(i % 10 == 0){
			// Thread.currentThread().yield();
			// }
			// if(i == 20){
			// try {
			// st1.join();
			// } catch (InterruptedException e) {
			// // TODO Auto-generated catch block
			// e.printStackTrace();
			// }
			// }
		}
		System.out.println(st1.isAlive());
	}
}

 

优先级改变的仅仅是概率 ,并不是优先全部执行完毕。

创建多线程的方法一:继承Thread类

三个线程的火车票抢票程序。存在线程的安全问题

 

//模拟火车站售票窗口,开启三个窗口售票,总票数为100张
//存在线程的安全问题
class Window extends Thread {
	static int ticket = 100;

	public void run() {
		while (true) {
			if (ticket > 0) {
				System.out.println(Thread.currentThread().getName() + "售票,票号为:"
						+ ticket--);
			} else {
				break;
			}
		}
	}
}

public class TestWindow {
	public static void main(String[] args) {
		Window w1 = new Window();
		Window w2 = new Window();
		Window w3 = new Window();
		
		w1.setName("窗口1");
		w2.setName("窗口2");
		w3.setName("窗口3");
		
		w1.start();
		w2.start();
		w3.start();
		
		
	}

}

static 为了能够让  三个线程共用。

创建多线程的方法二:通过实现的方式

 

/*
 * 创建多线程的方式二:通过实现的方式
 * 
 * 对比一下继承的方式 vs 实现的方式
 * 1.联系:public class Thread implements Runnable
 * 2.哪个方式好?实现的方式优于继承的方式
 *    why?  1 避免了java单继承的局限性
 *          2 如果多个线程要操作同一份资源(或数据),更适合使用实现的方式
 */

1 避免局限性:  比如一个学生类实现Runnable接口,多个学生的话代码冗余,而且如果学生继承了人的话,无法再去继承

//使用实现Runnable接口的方式,售票
/*
 * 此程序存在线程的安全问题:打印车票时,会出现重票、错票
 */

class Window1 implements Runnable {
	int ticket = 100;

	public void run() {
		while (true) {
			if (ticket > 0) {
//				try {
//					Thread.currentThread().sleep(10);
//				} catch (InterruptedException e) {
//					// TODO Auto-generated catch block
//					e.printStackTrace();
//				}
				System.out.println(Thread.currentThread().getName() + "售票,票号为:"
						+ ticket--);
			} else {
				break;
			}
		}
	}
}

public class TestWindow1 {
	public static void main(String[] args) {
		Window1 w = new Window1();
		Thread t1 = new Thread(w);
		Thread t2 = new Thread(w);
		Thread t3 = new Thread(w);
		
		t1.setName("窗口1");
		t2.setName("窗口2");
		t3.setName("窗口3");
		
		t1.start();
		t2.start();
		t3.start();
	}
}

与上面的一个程序相比,多个线程共用一个对象,即共享对象。 

 

下面代码中   Thread 的构造器要求传入一个Runnable对象

实际传的是PrintNum1,  是多态的一种体现。

//1.创建一个实现了Runnable接口的类
class PrintNum1 implements Runnable {
	//2.实现接口的抽象方法
	public void run() {
		// 子线程执行的代码
		for (int i = 1; i <= 100; i++) {
			if (i % 2 == 0) {
				System.out.println(Thread.currentThread().getName() + ":" + i);
			}
		}
	}
}

public class TestThread1 {
	public static void main(String[] args) {
		//3.创建一个Runnable接口实现类的对象
		PrintNum1 p = new PrintNum1();
//		p.start();
//		p.run();
		//要想启动一个多线程,必须调用start()
		//4.将此对象作为形参传递给Thread类的构造器中,创建Thread类的对象,此对象即为一个线程
		Thread t1 = new Thread(p);
		//5.调用start()方法:启动线程并执行run()
		t1.start();//启动线程;执行Thread对象生成时构造器形参的对象的run()方法。
		
		//再创建一个线程
		Thread t2 = new Thread(p);
		t2.start();
	}
}

底层原理:

调用  thread类里面的 run方法 执行当前对象的run方法

 

在构造器传入的时候给target 赋值,所以调用的run方法是传入的对象的run方法

 

 

2018年8月12日18:42:15 于易动

写的自己感觉很明白了,  不要去刻意追求学习那些设计模式之类的,

疯狂java里面说设计模式的理解要有一定的代码量做基础。

恩恩  不飘。

2018年8月27日21:42:34在易动吧把笔记补上了  还未整理。

 

 

发布了174 篇原创文章 · 获赞 54 · 访问量 11万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 技术黑板 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览