Java面向对象——多线程——上

Java面向对象——多线程——上

面向对象

多线程：

简单概念：Ctrl+Alt+Del(也就是在0数字旁边的.)看到进程了嘛！进程里面执行的程序里面就有很多的线程，当然你是看不到的懂吗？这都是编写代码的时候，程序员写的。当然你看过你打开软件的时候跳出了另外一个软件（也就是广告）吗？这就是又创建了一个进程，而这个进行里面有很多的线程，不是同时执行的哦，只是CPU在做着快速的切换。

当然，你懂的嘛！每次写博客的时候，我都是按照面向对象的思想去考虑的嘛！我们今天的面向对象是多线程。

当然Java已经把线程封装成了Java类，我们只要找到这个类，我们就可以操作线程了。这个线程类就是请往下看

（不是我找不到哦，是刚才没有下载API）。（算了，不忽悠你了，这个线程类就是Java.lang.包里面的Thread类）

什么是API？就是Java用面向对象的思想给我们这些酷毙的程序员封装好的核心类库，方便了我们的使用。

在线查看Java API点就我好

多线程 概述

1、进程： 是一个正在执行中的程序。

每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元（线程）。

2、线程：就是进程中的一个独立的控制单元。

线程控制着进程的执行。

一个进程中，至少或个以上的线程。

3、Java JVM 启动的时候会有一个进程 Java.exe

         (1)、该进程中至少有一个（当然就是多个）线程负责 Java 程序的执行。

         (2)、而且这个线程运行的代码存在于 main 方法中。

         (3)、该线程称为主线程。

4、扩展：其实更细节说明 Jvm ，Jvm 启动不止一个线程，还有负责垃圾回收机制的线程

(线程运行状态)

注意：还有一个状态（临时状态） 阻塞 具备执行资格，但没有执行权，可能cpu在执行别的线程。当冻结的线程被唤醒了他最初会到阻塞状态，再判断CPU是否空闲，空闲时到运行状态

                                             阻塞

                                                                  sleep()  ,wait()

被创建  start()   ------------>   运行  < ------------------------->冻结（放弃执行资格）

                                                    |            sleep()完  notify()

                                           run方法结束

                                             或  调用Stop方法

                            stop()        消亡

线程运行状态图：

如何创建线程：

创建线程的第一种方式：继承Thread类。

步骤：

1，定义类继承Thread。

2，复写Thread类中的run方法。

目的：将自定义代码存储在run方法。让线程运行。

3，调用线程的start方法，该方法两个作用：启动线程，调用run方法。

（当然，如果你想直接调用run方法也是可以的，但是那就不是多线程了）

代码示例:

class ThreadTest extends Thread{

public void run(){

线程运行代码;

}

}

class Test{

public static void main(String[] args){

ThreadTest threadTest = new ThreadTest();

thread.start();

}

}

简化格式：

class Test{

public static void main(String[] args){

new Thread(){

public void run(){

线程运行代码;

}

}.start();

}

}

创建线程的第二种方式：实现Runnable接口。

实现步骤：

1，定义类实现Runnable接口
2，覆盖Runnable接口中的run方法。将线程要运行的代码存放在该run方法中。
3，通过Thread类建立线程对象。
4，将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。

5，调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。

代码示例：

class RunnableTest implements Runnable{

public void run(){

线程运行代码;

}

}

class Test{

public static void main(String[] args){

RunnableTest runnableTest = new RunnableTest();
Thread thread = new Thread(runnableTest);
thread.start();
/*
简化到一步到为，new Thread(new Runnable()).start();

*/

}

}

简化格式：

class Test{

public static void main(String[] args){

new Thread(new Runnable(){

public void run(){

线程运行代码;

}

}).start();

}

}

为什么要将Runnable接口的子类对象传递给Thread的构造函数。

因为，自定义的run方法所属的对象是Runnable接口的子接口对象。

所以要让线程去指定指定对象的run方法。就必须明确该run方法所属对象。

实现方式和继承方式有什么区别：

(1)、实现方式好处：避免了单继承的局限性

(2)、在定义线程时：建议使用实现方式
(3)、两种方式区别：

1.继承Thread：线程代码存放在 Thread 子类 run 方法中

2.实现Runnable：线程代码存放在接口的子类的 run 方法中

总结建议：建议使用第二种线程创建方法。因为第二种方式更加体现面向对象思想。

多线程练习题

/*继承Thread类*/

class ThreadTest extends Thread{

ThreadTest(){}

ThreadTest(String ThreadName){

//把传递进行的线程名字赋值给父类的线程名字

super(ThreadName);

}

/*复写Thread类中的run方法*/

public void run(){

/*把代码封装在run方法里面*/

while(true){

/*打印下当前线程的名字*/

System.out.println(Thread.currentThread().getName()+"...run");

}

}

}

class Test{

public static void main(String[] args){

/*创建了一个线程对象*/

ThreadTest  t =  new ThreadTest ();

t.start();/*开启一个线程，并调用线程的run方法*/

//t.run();可以吗？可以的，只不过没有开启线程哦

/*注意：主线程也是一个线程哦。我们把代码定义在main方法中就等于又开启了一个线程哦*/

t.setName("ThreadTest");

while(true){

/*打印下当前线程的名字*/

System.out.println(Thread.currentThread().getName()+"...run");

//Thread-0...run

}

}

}

多线程好处：

原本我们如果是单线程的情况下，我们定义在死循环就一直运行死循环的代码，不会运行其他的代码。

多线程的好处就体现出来了，他可以让我们的代码实现同步运行。

发现运行结果每一次都不同。

因为多个线程都获取CPU的执行权。CPU执行到谁，谁就运行。

明确一点，在某一个时刻，只能有一个程序在运行。(多核除外)

CPU在做着快速的切换，以达到看上去是同时运行的效果。

我们可以形象把多线程的运行行为在互相抢夺CPU的执行权。

这就是多线程的一个特性：随机性。谁抢到谁执行，至于执行多长，CPU说的算。

为什么要覆盖run方法：

 Thread类用于描述线程。
 该类就定义了一个功能，用于存储线程要运行的代码。该存储功能就是run方法。
 也就是说Thread类中的run方法，用于存储线程要运行的代码。

线程有名字吗？

从运行的代码来看，原来线程都有自己默认的名称。

Thread-编号 该编号从0开始。

主线程有名字吗？

从运行的代码来看，主线程也有自己的名字就是main

线程(Thread)类中已经封装好的方法：

static Thread currentThread():获取当前线程对象。

getName(): 获取线程名称。

设置线程名称：setName或者构造函数。

注意：主线程不会设置名称，它的线程名是默认的(main);

线程练习

/*创建两个线程，

和主线程交替运行。

(太简单了吧，别着急,葫芦大半在后这只是葫芦的头部，尾部在后面)

*/

代码：

class ThreadTest extends Thread{

public void run(){

for(int x=1;x<=60;x++){

/*因为this代表的是本类对象，直接用.getName()获取对象的名字

this可以省略吗？答案是可以的。因为调用对象的方法默认有一个对象的引用，

这个对象就是this。

*/

System.out.println(/*this.*/getName()+"...run..."+x);

}

}

}

class Test{

public static void main(String[] args){

ThreadTest  t =  new ThreadTest ();

t.start();

for(int x=1;x<=60;x++){

/*

由于main方法调用时不需要对象，在这里this就不起作用了。

*/

System.out.println(Thread.currentThread().getName()+"...main..."+x);

}

}

}

注意：获取线程对象名称时，不建议使用this，为什么，因为不怎么通用，

不过Thread.currentThread().getName()这个方法就是通用的。

用多线程做一个多窗口卖票系统。

/*
需求：

简单的卖票程序，多个窗口卖票。

思路：

票是一个共享数据被多个窗口所操作。

窗口是一个线程，多个窗口应该是一个多线程。

步骤：

票，是共享数据，应该被static修饰起来。

多窗口，是多线程，应该创建多个线程来操作票。

*/

class Ticket extends Thread{

/*把线程创建传递进来的名字丢给父类带参数的构造函数*/

Ticket(StringThreadName){

super(ThreadName);

}

/*定义票数据，定义为共享数据，因为多个窗口卖的是同一个票资源*/

private static int tick =100; 

public void run(){

while(true){

/*如果还有票就打印下几号客户在买票，然后卖出去一张票，减一张票*/

if(tick>0){

System.out.println(tick+"号客户买票\n"+Thread.currentThread().getName()+"为"+tick+"号客户服务\t...卖第"+tick--+"票");

}

/*如果没有票了，就向客户致敬，然后跳出return跳出循环，方法结束*/

else{

System.out.println(Thread.currentThread().getName()+":哥们票卖完了，打烊了");

return;

}

}

}

}

class Test{

public static void main(String[] args){

new Ticket("1号窗口").start();//创建匿名线程对象，调用对象的start()方法。

new Ticket("2号窗口").start();

new Ticket("3号窗口").start();

new Ticket("4号窗口").start();

}

}

用多线程做一个多窗口卖票系统，并为多线程的安全问题进行解决。

如何找问题：

1，明确哪些代码是多线程运行代码。

2，明确共享数据。

3，明确多线程运行代码中哪些语句是操作共享数据的。

/*

需求：

简单的卖票程序，多个窗口卖票。

思路：

票是一个共享数据被多个窗口所操作。

窗口是一个线程，多个窗口应该是一个多线程。

步骤：

票，是共享数据，应该被static修饰起来。

多窗口，是多线程，应该创建多个线程来操作票。

*/

class Ticket implements Runnable{

/*private Object obj = new Object();*/

/*定义票数据，因为创建的是一个对象资源，所以保证了数据的共享，不用static也可以*/

private int tick =100; 

public void run(){

while(true){

/*如果还有票就打印下几号客户在买票，然后卖出去一张票，减一张票*/

synchronized(this){

if(tick>0){

try{

Thread.sleep(10);

/*由于考虑到如果客户有可能操作慢而导致延迟，所以加入线程延迟进行测试，我们是程序员必须要做到一些错误的排除，当然不能保证到万无一失，但也要做到尽量避免发生错误*/

}

catch(Exception e){

}

System.out.println(tick+"号客户买票\n"+Thread.currentThread().getName()+"为"+tick+"号客户服务\t...卖第"+tick--+"票");

}

/*如果没有票了，就向客户致敬，然后跳出return跳出循环，方法结束*/

else{

System.out.println(Thread.currentThread().getName()+":哥们票卖完了，打烊了");

return;

}

}

}

}

}

class Test{

public static void main(String[] args){

/*

这时要设置线程的名字的话，就要用Thread类的方法了，因为Runnable是

父接口，而设置线程的方法是在Thread类中的，所以可以直接用Thread对象调用。

*/

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.setName("1号窗口");

t2.setName("2号窗口");

t3.setName("3号窗口");

t4.setName("4号窗口");

t1.start();

t2.start();

t3.start();

t4.start();

/*创建线程对象，把资源当成参数进行传递（保证了资源的唯一），调用Thread类的start()方法。*/

}

}

在多窗口卖票系统中：

 通过分析，发现，打印出0，-1，-2等错票。

 多线程的运行出现了安全问题。

问题的原因：

当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分（CPU就切换到另外的线程去），还没有执行完，另一个线程参与进来执行。导致共享数据的错误。

解决办法：

对多条操作共享数据的语句，让一个线程都执行完。在执行过程中，其他线程不可以参与执行。

Java对于多线程的安全问题提供了专业的解决方式，就是同步代码块。

必须保证同步中只能有一个线程在运行。

同步代码块

用synchronized关键字来进行定义。

同步代码块格式

synchronized(唯一对象){

需要被同步的代码;

}

 对象如同锁，持有锁的线程可以在同步中执行。

没有持有锁的线程即使获取CPU的执行权，也进不去，因为没有获取锁。

好处：解决了多线程的安全问题。

弊端：多个线程需要判断锁，较为消耗资源，

同步的前提：

1，必须要有两个或者两个以上的线程。

2，必须是多个线程使用同一个锁。

从程序上看就解决了线程的同步问题，但是问题就来了，同步的锁是什么呢？

锁可以是任意对象，我们创建了一个对象，结果解决了问题。

但是这个问题是什么呢？

通过以上程序的测试，发现同步代码块使用的锁是this。

直观分析：

由于同步代码块使用的锁是任意对象，很直观就可以想到函数是需要被对象调用才执行的。

那么函数都有一个所属对象引用。就是this。

但这个对象是怎么传递进来的呢？

原来是调用函数的时候，函数内持有一个函数对象的引用。

那我们可不可以把同步定义在函数上？

答案是：...可以的。结果就有了同步函数。

同步函数：

所谓的同步函数就是在函数的返回值前面加一个synchronized关键字就是同步函数了。

使用同步函数注意事项：

一定要明确哪个代码是需要进行同步，如果同步函数中的代码都是需要同步的，就可以使用同步函数。

如果同步函数被静态修饰后，使用的锁是什么呢？

因为静态方法中也不可以定义this。所以很直观就把this去掉了。

但是这个对象又是谁呢？

静态进内存时，内存中没有本类对象，但是一定有该类对应的字节码文件对象。

类名.class  该对象的类型是Class

单例设计模式之懒汉式

对象是方法被调用时才初始化，也叫对象的延时加载

Single类进内存，对象还没有存在，只有调用了getInstance方法时，才建立对象。

代码：

class Single{

private Single(){}

private static Single single = null;

public  staticSingle getInstance(){

if(single==null){//避免每次都判断锁，只有当对象为null的情况下才判断

synchronized(Single.class){

if(single==null)/*如果一个线程跑到第一个if后死了，另一个线程进来创建了对象释放了锁，然后那个线程醒了，进来后还要判断*/

single =new Single();

}

}

return single;

}

}

线程同步注意的问题：

由于线程同步代码中可能嵌套同步，最容易导致的问题就是死锁。程序就停在那里不动了。

我们作为程序员，我应该尽量避免死锁的出线。

死锁代码：

class MyLock {

public static Object locka = new Object();

public static Object lockb = new Object();

}

class DeadLockTest implements Runnable {

private boolean flag;

DeadLockTest(boolean flag) {

this.flag = flag;

}

public void run() {

if (flag) {

while(true) {

synchronized (MyLock.locka) {

System.out.println(Thread.currentThread().getName()

+"...if locka ");

synchronized (MyLock.lockb) {

System.out.println(Thread.currentThread().getName()

+"..if lockb");

}

}

}

} 

else {

while (true) {

synchronized (MyLock.lockb) {

System.out.println(Thread.currentThread().getName()

+"..else lockb");

synchronized(MyLock.locka) {

System.out.println(Thread.currentThread().getName()

+".....else locka");

}

}

}

}

}

}

class Test {

public static void main(String[] args) {

Thread t1 = new Thread(new DeadLockTest(true));

Thread t2 = new Thread(new DeadLockTest(false));

t1.start();

t2.start();

}

}