java复习：多线程

最新推荐文章于 2024-06-17 22:13:03 发布

西红柿鸡蛋面U

最新推荐文章于 2024-06-17 22:13:03 发布

阅读量365

点赞数

分类专栏： JAVA 文章标签： java 多线程

本文为博主原创文章，未经博主允许不得转载。

本文链接：https://blog.csdn.net/YI_LI_A_E/article/details/48864165

版权

JAVA 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

引入：多线程和进程的区别
进程：正在执行的程序，每一个进程执行都有一个执行顺序路径，并封装为控制单元，一个进程至少有一个线程。
线程：进程中一个独立的控制单元，线程在控制着进程的执行，一个进程至少有一个线程。主线程：该线程中至少一个线程负责java程序的执行，而且这个线程的运行的代码存在于main方法中，该线程称之为主线程。

1、自定义线程（继承Thread类）

创建线程步骤：
（1）定义继承Thread类
（2）复写Thread类中run方法，将自定义代码存储在run方法中，让线程运行
（3）调用线程的start方法。该线程开始执行，jvm调用该线程的run方法。
示例如下：

class Demo extends Thread
{
    public void run()
    {
        for(int x=0;x<60;x++)
        {
            System.out.println("Demorun+"+x);
        }
    }
}
class ThreadDemo
{
    public static void main(String[] args)
    {
        Demo d=new Demo();
        d.start();
        for(int x=0;x<60;x++)
        {
            System.out.println("HelloWorls+++++"+x);
        }
    }
}

注释：程序解读，每次结果不同，因为多个线程都在抢夺cpu的执行权，某一时刻只能只有一个程序在运行，cpu做着快速的执行切换。这就是多线程的特点：随意性。

1.1 创建线程run和start特点，为什么要覆盖run方法？

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

1.2 获取线程对象以及名称

(1)Thread类中有setName()和getName()方法
(2)static Thread currentThread() 返回对当前正在执行的线程对象的引用
事例如下：

class Test extends Thread
{
    private String name;
    Test(String name)
    {
        super(name);
    }       
    public void run()
    {
        for(int x=0;x<60;x++)
        {
            //读取线程名称的方法应用
            System.out.println(this.getName()+"+run+"+x);
            System.out.println(Thread.currentThread().getName()+"run---"+x);
        }
    }
}
class ThreadDemo
{
    public static void main(String[] args)
    {
        Test t1=new Test("one");
        Test t2=new Test("two++++++++++++++++");
        t1.start();
        t2.start();
        for(int x=0;x<60;x++)
        {
            System.out.println("main+++++"+x);
        }
    }
}

1.3 练习：简单的买票程序

class Ticket extends Thread
{
    private static int tick=100;//因为是四个窗口共享400张票，static用于类加载时候                                   的初始化数据与对象无关
    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 t1=new Ticket();
        Ticket t2=new Ticket();
        Ticket t3=new Ticket();
        t1.start();
        t2.start();
        t3.start();
    }
}

2、创建线程（实现Runnable接口）

步骤：
(1) 定义实现Runable接口中的方法
(2) 覆盖Runable接口中的方法
(3)通过Thread类建立线程对象
(4)将Runable接口的子类对象作为实际参数传递给Thread类的构造函数

//定义实现Runnable接口的方法，覆盖
class Ticket implements Runnable
{
    private 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(t);
        Thread t2=new Thread(t);
        Thread t3=new Thread(t);
        t1.start();
        t2.start();
        t3.start();
    }
}

2.1 为什么要将Runnable接口的子类对象作为实际参数给Thread方法
Runable接口：应该由打算通过某一线程执行其实例的类来实现。类比较定义一个称为run的无参数方法。Thread类中有一个方法Thread(Runable target)接受一个Runable接口对象。
2.2 继承Thread类和实现Runable接口的方法的区别

(1)继承Thread类是将线程代码放到Thread子类的run方法中。
(2)实现Runnable类，线程代码存放在接口子类的run方法中。实现方式避免了单继承的局限性。
2.3 Thread类、Runnable接口内部源码关系模拟代码
Thread类

class Thread
{
    private Runnable r ;
    Thread()
    {}
    Thread(Runnable r)
    {
        This.r = r;
    }

    public void run()
    {
        if(r !=null)
        r.run();
    }
    public void start()
    {
        run();
    }
}

class ThreadImpl implements Runnable
{
    public void run()
    {
        System out println("runnable run" );
    }
}

 class ThreadDemo
 {
    public static void main(String[] args)
    {
        ThreadImpl i = new ThreadImpl();
        Thread t = new Thread(i);
        t.start();
    }
 }

Runable 接口

class SubThread extends Thread
{
    public void run()
    {
        System out println("hahah" );
    }
}
class ThreadDemo
{
    public static void main(String[] args)
    {
        SubThread s = new SubThread();
        s.start();
    }
}


3、多线程的安全问题
---------
事例引入：

class Ticket implements Runnable
{
private int tick=10;
public void run()//不可抛异常，run是复写了接口异常
{
while(true)
{
if(tick>0)
{
try{Thread.sleep(10);
}
catch(Exception e){
}
System.out.println(Thread.currentThread().getName()+”run–>”+tick–);
}
}
}
}
class TicketDemo
{
public static void main(String[] args)
{
Ticket t=new Ticket();
Thread t1=new Thread(t);
Thread t2=new Thread(t);
Thread t3=new Thread(t);
t1.start();
t2.start();
t3.start();
}
}

出现了打印错票的问题0、-1，出现了安全问题。
![这里写图片描述](https://img-blog.csdn.net/20151001230743851)
**分析**：当多余语句在操作同一线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完。另一线程参与进来执行。导致共享数据的错误
**解决方法**：对多条操作共享数据时，只能让一个线程执行完，在执行完成后，其他线程不可以参与其中。

 - 3.1  **同步代码块**

对象如同锁，持有锁的线程可以在同步中执行。没有持有锁的线程即使获取了cpu的执行权也进不去，因为没有锁。java对多线程的安全问题提供了专业的解决方式:

synchronized(对象)
{
需要同步的代码
}


前提：
(1)必须由两个或两个以上的线程
(2)必须多个线程使用同一个锁
(3)必须保证同步中只能由一个线程执行
好处：解决了多线程的安全的问题。
弊端：多个线程需要判断锁，较为消耗资源。
事例说明：

class Ticket implements Runnable
{
private int tick=100;
Object obj=new Object();//这个不要忘，这个要使用同一个锁
public void run()//不可抛异常，run是复写了接口异常
{
while(true)
{
synchronized(obj)
{
if(tick>0)
{
try{Thread.sleep(10);
catch(Exception e){}
System.out.println(Thread.currentThread().getName()+”run–>”+tick–);
}
}
}
}
}
class TicketDemo
{
public static void main(String[] args)
{
Ticket t=new Ticket();
Thread t1=new Thread(t);
Thread t2=new Thread(t);
Thread t3=new Thread(t);
t1.start();
t2.start();
t3.start();
}
}


 - **3.2 同步函数**
 - **3.2.1银行存款事例的应用**

/*需求：银行有一个金库，有两储户分别存300，每次都存100，存三次
注意事项：(1)明确哪些代码是多线程运行代码
(2)明确共享数据
(3)明确多线程运行代码中哪些语句是操作共享数据*/
class Bank
{
private int sum=0;
public synchronized void add(int n)
{
sum=sum+n;
try{Thread.sleep(10);}catch(Exception e){}
System.out.println(Thread.currentThread().getName()+”sum–>”+sum);
}
}
class Cus implements Runnable
{
private Bank b=new Bank();
public void run()
{
for(int x=0;x<3;x++)
{
b.add(100);
}
}
}
class BankDemo
{
public static void main(String[] args)
{
Cus c=new Cus();
Thread t1=new Thread(c);
Thread t2=new Thread(c);
t1.start();
t2.start();
}
}

 - **3.2.2     同步函数在卖票程序中的应用**

class Ticket implements Runnable
{
private int tick=100;
public synchronized void run()//具有同步特性，0进入后就锁了，0进入就锁了，0计入后循环出不来，要清楚哪些需要同步
{
while(true)
{
if(tick>0)
{
System.out.println(Thread.currentThread().getName()+”sale–>”+tick–);
}
}
}
}

class Ticket implements Runnable
{
private int tick=100;
public void run()
{
while(true)
{
this.show();
}
}
public synchronized void show()
{
if(tick>0)
{
try{Thread.sleep(10);}catch(Exception e){}
System.out.println(Thread.currentThread().getName()+”sale–>”+tick–);
}
}
}
class TicketDemo
{
public static void main(String[] args)
{
Ticket t=new Ticket();
Thread t1=new Thread(t);
Thread t2=new Thread(t);
Thread t3=new Thread(t);
t1.start();
t2.start();
t3.start();
}
}


 - **3.2.3  对同步函数锁的讨论**
函数需要被对象调用。那么函数都有一个所属对象引用，this，所以同步函数用锁为this

/*
用程序加以验证：（前提：必须由两个或两个以上的线程、必须多个线程使用同一个锁、必须保证同步中只能由一个线程执行)
所以用两线程卖票，一个在同步代码块，一个在同步函数，如果同步则不会有错票*/
class Ticket implements Runnable
{
private int tick=100;
boolean flag=true;
public void run()
{
if(flag)
{
while(true)
{
synchronized(this)//第一个线程为同步代码块且锁是this
{
if(tick>0)
{
try{Thread.sleep(10);}
catch(InterruptedException e){e.printStackTrace();}
System.out.println(Thread.currentThread().getName()+”one”+tick–);
}
}
}
}
else
while(true)
show();//第二个线程使用同步函数，锁也是this
}
public synchronized void show()
{
if(tick>0)
{
try{Thread.sleep(10);}
catch(InterruptedException e){e.printStackTrace();}
System.out.println(Thread.currentThread().getName()+”two”+tick–);
}
}
}
class TicketDemo
{
public static void main(String[] args)
{
Ticket t=new Ticket();
Thread t1=new Thread(t);
Thread t2=new Thread(t);
t1.start();
try{Thread.sleep(10);}catch(Exception e){}
t.flag=false;
t2.start();
}
}

结果没有错票，说明同步函数的锁为this。

-  **3.2.4 静态同步函数锁**



静态同步函数锁为class对象

/静态进内存没对象，由类调用，类进入内存先封装成class的对象，即Ticket.class/
class Ticket implements Runnable
{
private static int tick=100;//注意设置成静态
boolean flag=true;
public void run()
{
if(flag)
{
while(true)
{
synchronized(Ticket.class)//使用锁Ticket.class
{
if(tick>0)
{
try{Thread.sleep(10);}
catch(InterruptedException e){e.printStackTrace();}
System.out.println(Thread.currentThread().getName()+”one”+tick–);
}
}
}
}
else
while(true)
show();
}
public static synchronized void show()//注意设置成静态,静态进内存没有对象，由类调用，类进内存先封装成class的对象Ticket.class
{
if(tick>0)
{
try{Thread.sleep(10);}
catch(InterruptedException e){e.printStackTrace();}
System.out.println(Thread.currentThread().getName()+”two”+tick–);
}
}
}
class TicketDemo
{
public static void main(String[] args)
{
Ticket t=new Ticket();
Thread t1=new Thread(t);
Thread t2=new Thread(t);
t1.start();
try{Thread.sleep(10);}catch(Exception e){}
t.flag=false;
t2.start();
}
}

同样程序可以正常的运行。
## 4 单例设计模式和死锁 ##

 - **4.1 单例设计模式**

class Single
{
private static Single s=null;
private Single(){}
public static Single getInstance()
{
synchronized(Single.class)
{
if(s==null)
s=new Single();
}
}
return s;
}

是延时加载的方式。当多线程访问懒汉式的方法内对共性数据进行多条语句的操作，但是容易产生安全问题，为了解决，加入了同步机制，解决安全问题。同时使用双重判断的形式解决效率的问题。

 - **4.2 死锁**
 (1)同步中嵌套同步，锁却不同。同步函数中有同步代码块，同步代码块中有同步函数。

class Ticket implements Runnable
{
private int tick=100;
Object obj=new Object();
boolean flag=true;
public void run()
{
if(flag)
{
while(true)
{
synchronized(obj)//同步代码块中有同步函数
{
show();
}
}
}
else
while(true)
show();
}
public synchronized void show()//同步函数中还有同步代码块
{
synchronized(obj)
{
if(tick>0)
{
try{Thread.sleep(10);}
catch(InterruptedException e){e.printStackTrace();}
System.out.println(Thread.currentThread().getName()+”two”+tick–);
}
}
}
}
class TicketDemo
{
public static void main(String[] args)
{
Ticket t=new Ticket();
Thread t1=new Thread(t);
Thread t2=new Thread(t);
t1.start();
try{Thread.sleep(10);}catch(Exception e){}
t.flag=false;
t2.start();
}
}

(2)一个死锁的实例：

class Test implements Runnable
{
boolean flag;
Test(boolean flag)
{
this.flag=flag;
}
public void run()
{
if(flag)
{
synchronized(MyLock.locka)
{
System.out.println(“if locka”);
synchronized(MyLock.lockb)
{
System.out.println(“if lockb”);
}
}
}
else
{
synchronized(MyLock.lockb)
{
System.out.println(“else lockb”);
synchronized(MyLock.locka)
{
System.out.println(“else locka”);
}
}
}
}
}
class MyLock
{
static Object locka=new Object();
static Object lockb=new Object();
}

class Demo
{
public static void main(String[] args)
{
Test t1=new Test(true);
Test t2=new Test(false);

    Thread t3=new Thread(t1);
    Thread t4=new Thread(t2);

    t3.start();
    t4.start();
}

}
“`
这里写图片描述
程序终止，无法继续进行。

西红柿鸡蛋面U

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java复习：多线程

引入：多线程和进程的区别进程：正在执行的程序，每一个进程执行都有一个执行顺序路径，并封装为控制单元，一个进程至少有一个线程。线程：进程中一个独立的控制单元，线程在控制着进程的执行，一个进程至少有一个线程。主线程：该线程中至少一个线程负责java程序的执行，而且这个线程的运行的代码存在于main方法中，该线程
复制链接

扫一扫