Java线程及安全性问题

拼搏现实的明天。 2022-08-13 10:00 212阅读 0赞

多线程基础知识：  
线程：就是进程中一个负责程序执行的控制单元（执行路径），一个进程中可以包含多个线程，称之为多线程。  
一个进程当中至少要有一个线程。  
开启多个线程是为了同时运行多部分代码，每个线程都有自己运行的内容，这个内容可以称之为线程要执行的任务。  
好处：解决了多部分同时运行的问题  
弊端：线程太多导致效率降低。  
其实程序的执行都是cpu在做着快速的切换完成的，这个切换是随机的。  
JVM启动时就启动了多个线程，至少有两个线程：执行main函数的线程（该线程任务代码都定义在main函数中），负责垃圾回收机制的线程。  
  
如何创建一个线程？  
1.继承Thread类，  
创建线程的目的就是为了开启一条执行路径，去运行指定的代码，并且是实现与其它代码同时运行。  
而运行的指定代码就是这个执行路径的任务。  
自定义线程的任务存放位置：  
JVM创建的主线程的任务都定义在了主函数中，而Thread类用于描述线程，线程是需要任务的，所以Thread类也对任务描述。  
这个任务就是通过Thread类中的run方法来体现的。简而言之，run方法就是封装自定义线程运行任务的函数。  
run方法中定义就是线程要运行的任务代码。开启线程就是为了运行指定代码。所以只有继承Thread类并重写run方法。并将制定运行的代码定义在润方法中。  
步骤：  
 1.定义一个类继承Thread类。  
 2.覆盖Thread类中的run方法。  
 3.直接创建Thread类子类的对象，创建线程。  
 4.调用start（）方法，开启线程并调用线程的run方法执行  
 可以通过Thread的getName（）获取线程的名称：Thread——现成的编号（从0开始）。主线程的名字main。  
2.实现runnable接口  
步骤：  
 1.定义类实现runnable接口  
 2.实现接口中的run（）方法，将线程的任务代码封装到run方法中  
 3.通过Thread类创建线程的对象，并将runnable接口的子类对象作为Thread类的构造函数的参数进行传递。  
 因为线程的任务都封装在runnable接口子类对象的run方法中，只有作为实参传递参能运行任务代码。所以在创建线程对象时就要明确要运行的任务代码。  
 4.调用线程的start方法开启线程。  
 runnable的出现仅仅是将线程的任务进行了对象的封装。  
  
CPU的执行资格：可以随时被CPU处理的状态  
CPU的执行权：正在被CPU执行的状态。  
释放执行权的同时释放执行资格，线程就有运行状态走到冻结状态。  
3.继承Thread与实现Runnable的主要区别（Runnable的好处）：  
实现Runnable：  
 1.将线程的任务从线程的子类中分离出来，进行了单独的封装。即：按照面向对象的思想将任务封装成对象。  
 2.避免java单继承的局限性。所以，使用接口实现的方法更常用。  
4.多次启动一个线程是非法的。  
 同一资源多个线程使用时（如火车卖票），防止重复数据利用（重复买票）的方法：  
 1.将车票资源静态化。（不利于资源变更，或者卖多种票）。

2.使用实现Runnable方法，创建一个线程任务对象。多个线程使用一个资源。（方便使用）

线程同步问题：

5.线程安全性问题产生的原因：  
 1.存在多个线程操作共享数据  
 2.每个线程中操作共享数据的代码有多条。（产生时间差）  
 当一个线程在执行操作共享数据的多条代码过程中，其他线程参与了运算。就会导致线程安全性问题的产生。  
 解决思路：将多条操作共享数据的线程代码封装起来，当有现成在执行这些代码的时候，其他线程是不可以参与运算的。  
 必须要等待当前线程把这些代码全部执行完毕后，其他线程才可以参与运算。  
 3.synchronized：同步代码块。  
 1.放在对向前，限制一段代码格式：  
 synchronized （对象）//对象：  
 \{  
  
 \}  
 2.修饰方法的格式：  
 修饰词 （public，static）synchronized 返回值类型 方法名（）  
 \{  
 //方法体  
 \}  
 注意： 同步函数的锁是this。  
 静态同步函数的锁该函数所属的字节码文件对象。即：getClass()获取也可用类名.class表示。  
 同步函数和同步代码块的区别：  
 同步函数的锁固定为this。而同步代码块的锁是任意的。建议使用同步代码块的锁。  
  
 4. 同步的好处：解决了线程的安全问题。  
 同步的弊端：相对降低效率。因为同步外的线程都会判断同步锁。  
 5.同步的前提：  
 同步中只有多线程的情况才有同步的必要。  
 同步中只有多个线程使用的是同一个同步锁。  
  
6.线程间通讯：  
 多个线程在处理同一资源，但是任务不同。  
7.等待/唤醒机制：  
 1.wait（）：让线程处于冻结状态，释放线程的执行权和执行资格。被wait的线程被存储在线程池中。  
 2.notify（）：用于唤醒线程池中的一个（需注意：是随机的一个）线程。使线程具有执行资格。  
 3.notifyAll（）：用于唤醒线程池中的所有线程。  
 这些方法都必须定义在同步中。因为这些方法都是用于操作线程状态的方法。必须要明确到底操作的是哪个锁上的线程。锁名.notify（）。  
 为什么操作线程的方法wait，notify，notifyAll放在了Object类中？  
 因为这些方法都是监视器方法。监视器其实就是一个锁，锁可以是任意的对象，任意的对象调用的方法必须定义在Object类中。  
8.多生产者多消费者问题：  
 while判断标记，解决了线程获取执行权后受否需要运行。if判断标记只运行一次，会导致不该运行的线程运行了出现数据错误的情况。  
 notifyAll解决本方线程一定会唤醒对方线程。notify只唤醒一个线程，如果唤醒本方线程则没有意义。问题没有得到解决。  
 而使用while+noyify会出现死锁问题。  
 只有while+notifyAll才能完全解决问题。  
  
9.JDK 1.5之后，将同步和锁封装成了对象，并将操作锁的隐式方式定义带了该对象当中，将隐式动作转换成显示动作。  
 lock.lock（）  
 代码；  
 lock.unlock（）  
10.  
 Lock接口：它的出现替代了同步代码块和同步函数，将同步的隐式锁操作转换成了显示锁操作。同时更为灵活，可以在一个锁上添加多个监视器。  
 lock（）：获取锁。  
 unlock（）：释放锁。 通常定义在finally代码块中。  
 Condition接口：它的出现替代了Object类中的wait，notify和notifyAll方法。将这些监视器方法单独进行了封装，变成Condition监视器对象。  
 await（）：等待  
 signal（）：唤醒一个线程  
 signalAll（）：唤醒所有线程  
11.wait和sleep的区别：  
 1.wait可以指定或者不指定时间，sleep必须指定时间。  
 2.在同步中时，对CPU的执行权和锁的处理不同。wait释放CPU的执行权，释放锁。而sleep释放执行权，不释放锁。  
  
12.停止线程的方式：  
 1.stop方法：已经过时。  
 2.run方法结束。  
 怎么控制线程任务的结束？  
 任务中都有循环结构，只要控制住循环就可以结束任务。控制循环通常就用定义标记来完成。使用条件标记来结束线程。  
 但是如果线程处于了冻结状态，就无法读取标记。  
 3.可以使用interrupt方法强制将线程从冻结状态强制恢复成可运行状态中来，让线程具备CPU的执行资格，这时的强制动作会引起InterruptException异常，必须要对其处理。  
13.守护线程setDeamon：  
 守护线程：即后台线程，用户线程，其他都和一般线程（前台线程）一样，就是结束的时候不需要手动结束。

设置守护线程的方法：线程对象.setDeamon（boolean on）;必须在线程启动前调用。

下面一个简单的弹球程序演示线程的创建等简单问题：

import java.awt.*; 
    import java.awt.event.*;
    /* 定义弹子类 */
    class Marble extends Thread
    {
       Table table=null;
       int x,y,xdir,ydir;
      public Marble(Table _table,int _x,int _y,int _xdir,int _ydir)
    	{
    	  table=_table;    //使用该参数，是为了能获取到窗口的大小
    	  x=_x;            //x坐标
    	  y=_y;            //y坐标
          xdir= _xdir;     //x方向速度
          ydir= _ydir;     //y方向速度
    	}
     public void run()
      {
       while(true)
        {
          if((x>(table.getSize().width)-25)||(x<0))
    			xdir*=(-1); //超过台子x方向边界后,反方向运行
          if((y>(table.getSize().width)-25)||(y<0))
    			ydir*=(-1);	//超过台子y方向边界后,反方向运行
    	  x+=xdir;            //坐标递增 以实现移动
    	  y+=ydir;
          try{ sleep(30);    //延时时间（1/刷新率）
    	  } catch(InterruptedException e)
             {System.err.println("Thread interrupted");}
    	   table.repaint();  //重绘图形     
       }
     }
     public void draw(Graphics g)
      {
        g.setColor(Color.black);   //弹子为黑色
        g.fillOval(x,y,30,30);     //画圆
        g.setColor(Color.white);   //弹子上的亮点为白色
        g.fillOval(x+5,y+5,8,6);   
      }
    }
    /* 定义弹子球台类 */
    class Table extends Frame implements ActionListener
    {
    	 Button start=new Button("开始");
    	 Marble marbles[]=new Marble[5];   //建立弹子线程类对象数组
    	 int v=2;                          //速度最小值
    	public Table()
    	{
    		super("弹子台球");
    		setSize(300,300); 
    		setBackground(Color.cyan); //背景
    		setVisible(true);
    		setLayout(new FlowLayout());
    		add(start);
    		start.addActionListener(this);
    		validate();
    		addWindowListener(new WindowAdapter()
    		{
    		 public void windowClosing (WindowEvent e)
    			{System.exit(0);}
    		} );
    	}
     public void actionPerformed(ActionEvent ae)
      {
    	 for(int i=0;i<marbles.length;i++)
    		{  //随机产生弹子的速度和坐标
    		  int xdir=i*(1-i*(int)Math.round(Math.random()))+v;
              int ydir=i*(1-i*(int)Math.round(Math.random()))+v;
    		  int x=(int)(getSize().width*Math.random());
    		  int y=(int)(getSize().height*Math.random());
    		  //实例化弹子线程对象
    		  marbles[i]=new Marble(this,x,y,xdir,ydir);
              marbles[i].start();
    	   }
      }
    	public void paint(Graphics g)
    	{
    		for(int i=0;i<marbles.length;i++)
              if(marbles[i]!=null)
                 marbles[i].draw(g);
    	}
    }
    /* 定义主类 */
    public class Example7_5
    {
    	public static void main(String args[])
    	{
    		Table table=new Table();
    	}
    }

线程安全问题出现的事例：

class Process
    {
    	public static void main(String[] args) 
    	{
    		P p1 = new P();
    		P p2 = new P();
    		Thread t1 = new Thread(p1,"线程1");
    		Thread t2 = new Thread(p1,"线程2");
    		t1.start();
    		t2.start();
    	}
    }
    class P implements Runnable
    {
    	int num = 100;
    	public void run()
    	{
    		while(num>0){
    			System.out.println(num+":"+Thread.currentThread().getName());//;1
    			num--;//2
    		}
    	}
    }
    /*
    出错情况：代码中的1,2，运行之间可能出现线程转换，致使num还没来得及减少，就又被另一线程使用，出现重复使用的情况。
    
    100:线程1
    100:线程2
    99:线程1
    97:线程1
    */