Java学习个人备忘录之多线程

进程:正在进行中的程序(直译)。

线程:就是进程中一个负责程序执行的控制单元(执行路径)
一个进程中可以有多个执行路径,称之为多线程。

一个进程中至少要有一个线程。

开启多个线程是为了同时运行多部分代码。

每一个线程都有自己运行的内容。这个内容可以称为线程要执行的任务。

多线程的好处:解决了多部分同时运行的问题。

多线程的弊端:线程太多回到效率的降低。

其实应用程序的执行都是cpu在做着快速的切换完成的。这个切换是随机的。

jvm启动时就启动了多个线程,至少有两个线程可以分析的出来。

1。执行main函数的线程
该线程的任务代码都定义在main函数中
2。负责垃圾回收的线程.

class Demo extends Object  
{  
    public void finalize()  //用来回收  
    {  
        System.out.println("demo ok");  
    }  
}  
  
class ThreadDemo  
{  
    public static void main(String[] args)  
    {  
        new Demo();  
        new Demo();  
        new Demo();  
        System.gc();  
        System.out.println("Hello World!");  
    }  
}  

 

多线程的创建方式--继承Thread类

步骤:
1。定义一个类继承Thread类
2。覆盖Thread类中的run方法
3。直接创建Thread的子类对象创建线程
4。调用start方法开启线程并调用线程的任务run方法执行。

可以通过Thread的getName获取线程的名称Thread-编号(从0开始)

主线程的名字就是main.

class Demo extends Thread  
{   
    private String name;  
    Demo(String name)  
    {  
        super(name);//自定义线程的名称  
        this.name = name;  
    }  
    public void run()  
    {  
        show();  
    }  
    public void show()  
    {  
//      System.out.println(name+"........x="+x+".......name="+getName());  
        System.out.println(name+"........x="+x+".......name="+Thread.currentThread().getName());//当前运行线程的名称。 
    }  
}  
  
class ThreadDemo2  
{  
    public static void main(String[] args)  
    {  
        /* 
        创建线程的母的是为了开启一条执行路径,去运行指定的代码和其他代码实现同时运行。
 
        而运行的指定代码就是这个执行路径的任务。
 
        jvm创建的主线程的任务都定义在了主函数中。
 
        而自定义的线程它的任务在哪儿呢? 
        Thread类用于描述线程,线程是需要任务的,所以Thread类也对任务的描述。
        这个任务就是通过Thread类中的run方法来体现。也就是说,run方法就是封装自定义线程运行任务的函数。
 
        run方法中定义就是线程要运行的任务代码。
         
        开启线程是为了运行指定代码,所以只有继承Thread类,并复写run方法。
        将运行的代码定义在run方法中即可。
 
        */  
        Demo d1 = new Demo("旺财");  
        Demo d2 = new Demo("xiaoqiang");  
        //d1.run();  
        //d2.run();  
        d1.start(); //开启线程,调用run方法  
        d2.start();  
        System.out.println("over....."+Thread.currentThread().getName());  
    }  
}  

 

创建多线程的第二种方式--实现Runnable接口

1。定义类实现Runnable接口
2。覆盖接口中的run方法,将线程的任务代码封装到run方法中。
3。通过Thread类创建线程对象,并将Runnable接口的子类对象作为Thread类的构造函数的参数进行传递。
  为什么? 因为线程的任务都封装在Runnable接口子类对象的run方法中
  所以要在线程对象创建时就必须明确要运行的任务。
4。调用线程对象的start方法开启线程.

class Demo implements Runnable  
{  
    public void run()  //Runnable里只有一个run方法  
    {  
        show();  
    }  
    public void show()  
    {  
        for (int x=0; x<20 ; x++ )  
        {  
            System.out.println(Thread.currentThread().getName()+"....."+x);  
        }  
    }  
}  
class TreadDemo  
{  
    public static void main(String[] args)  
    {  
        Demo d = new Demo();  
        Thread t1 = new Thread(d); //将d传进去  
        Thread t2 = new Thread(d);  
        t1.start();  
        t2.start();  
    }  
}

 

实现Runnable接口的好处
1。将线程的任务从线程的子类中分离出来,进行了单独的封装。
按照面向对象的思想将任务的封装成对象。
2。避免了java单继承的局限性。

所以,创建线程的第二种方式较为常用.

 

例子:卖票。
四个人一起卖100张票

第一种方法
class Ticket extends Thread  
{  
    private static int num = 100; //这个变量要共享,所以要加静态  
      
    public void run()  
    {  
        sale();  
    }  
  
    public void sale()  
    {  
        while(true)  
        {  
            if (num>0)  
            {  
                System.out.println(num--);  
            }  
        }  
    }  
}  
class TicketDemo  
{  
    public static void main(String[] args)  
    {  
        Ticket t1 = new Ticket();  
        Ticket t2 = new Ticket();  
        Ticket t3 = new Ticket();  
        Ticket t4 = new Ticket();  
  
        t1.start();  
        t2.start();  
        t3.start();  
        t4.start();  
    }  
}

 

第二种方法

class Ticket implements Runnable  
{  
    private int num = 100;  
      
    public void run()  
    {  
        sale();  
    }  
  
    public void sale()  
    {  
        while(true)  
        {  
            if (num>0)  
            {  
                try{Thread.sleep(10);}catch(InterruptedException e){}  
                System.out.println(Thread.currentThread().getName()+"....."+num--);  
            }  
        }  
    }  
}  
class TicketDemo  
{  
    public static void main(String[] args)  
    {  
        Ticket t = new Ticket();     
            //因为只创建了一个对象,但是下面开启了4个进程,所以就等于4个人卖共同卖100张票  
        Thread t1 = new Thread(t);  
        Thread t2 = new Thread(t);  
        Thread t3 = new Thread(t);  
        Thread t4 = new Thread(t);  
  
        t1.start();  
        t2.start();  
        t3.start();  
        t4.start();  
    }  
}

 

线程安全问题产生的原因

1。多个线程在操作共享数据。
2。操作共享数据的线程代码有多条。

当一个线程在执行操作共享数据的多条代码过程中,其他线程参与了运算,
就会导致线程安全问题的产生。


解决思路:
就是将多条操作共享数据的线程代码封装起来,当有线程在执行这些代码的时候,
其他线程是不可以参与运算的。
必须要当前线程把这些代码都执行完毕后,其他线程才可以参与运算。

在java中用,同步代码块就可以解决这个问题.

 
同步代码块
格式:
synchronized(对象) 
{ 
    需要被同步的代码 
}

 

class Ticket implements Runnable  
{  
    private int num = 100;  
    Object obj = new Object();  
  
    public void run()  
    {  
        sale();  
    }  
  
    public void sale()  
    {  
	//Object obj = new Object();  //它在这是错误的,这样每开启一个线程,就创建一把锁,一同是4个线程4个锁  
        while(true)  
        {  
            synchronized(obj)  //同步代码块  
            {  
                if (num>0)  
                {  
                    try{Thread.sleep(10);}catch(InterruptedException e){}  
                    System.out.println(Thread.currentThread().getName()+"....."+num--);  
                }  
            }  
        }  
    }  
}  
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);  
        Thread t4 = new Thread(t);  
  
        t1.start();  
        t2.start();  
        t3.start();  
        t4.start();  
    }  
}

同步的好处:解决了线程的安全问题。
同步的弊端:相对降低了效率,因为同步外的线程的都会判断同步锁。
同步的前提:必须有多个线程并使用同一锁.

 
实例:储户,两个,每个都到银行存钱,每次存100,共存三次。
class Bank  
{  
    private int sum;  
//  private Object obj = new Object();  
    public synchronized void add(int num)  //也可以用同步函数  
    {  
//      synchronized(obj)  
//      {  
            sum = sum + num;  
            System.out.println("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();  
    }  
}

 

验证同步函数的锁
class Ticket implements Runnable  
{  
    private int num = 100;  
    Object obj = new Object();  
    boolean flag = true;  
    public void run()  
    {  
//      Object obj = new Object();  //它在这是错误的,这样每开启一个线程,就创建一把锁,一同是4个线程4个锁  
        if (flag)  
        {  
            while(true)  
            {  
                synchronized(this)  //同步代码块  
                {  
                    if (num>0)  
                    {  
                        try{Thread.sleep(10);}catch(InterruptedException e){}  
                        System.out.println(Thread.currentThread().getName()+"...obj..."+num--);  
                    }  
                }  
            }  
        }  
        else   
            while(true)  
            show();  
    }  
  
    public synchronized void show()  //但是可以这样用,把需要同步的代码封装起来。 
    {  
        if (num>0)  
        {  
            try{Thread.sleep(10);}catch(InterruptedException e){}  
            System.out.println(Thread.currentThread().getName()+"...function..."+num--);  
        }  
    }  
}  
  
class SynFunctionLockDemo  
{  
    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(InterruptedException e){}  
        t.flag = false;  
        t2.start();  
    }  
}

 

同步函数使用的锁是this。

同步函数和同步代码块的区别:
  同步函数的锁是固定的this。
  同步代码块的锁是任意对象。

建议使用同步代码块.

 
验证静态同步函数的锁
class Ticket implements Runnable  
{  
	private static int num = 100;  
	Object obj = new Object();  
	boolean flag = true;  
	public void run()  
	{  
		//Object obj = new Object();  //它在这是错误的,这样每开启一个线程,就创建一把锁,一同是4个线程4个锁  
		if (flag)  
		{  
		while(true)  
		{  
		synchronized(this)  //同步代码块  
		{  
		if (num>0)  
		{  
		try{Thread.sleep(10);}catch(InterruptedException e){}  
		System.out.println(Thread.currentThread().getName()+"...obj..."+num--);  
		}  
		}  
		}  
		}  
		else   
		while(true)  
		this.show();  
	}  

	public static synchronized void show(Ticket.class)  //但是可以这样用,把需要同步的代码封装起来。 
	{  
		if (num>0)  
		{  
			try{Thread.sleep(10);}catch(InterruptedException e){}  
			System.out.println(Thread.currentThread().getName()+"...function..."+num--);  
		}  
	}  
}  

class SynFunctionLockDemo  
{  
	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(InterruptedException e){}  
		t.flag = false;  
		t2.start();  
	}  
}

静态的同步函数使用的锁是该函数所属字节码文件对象可以用getClass方法获取,也可以用当前 类名.class 表示.

 
多线程下的单例
饿汉式
class Single  
{  
	private static final Single s = new Single();  
	private Single(){}  
	public static Single getInstance()  
	{  
		return s;  
	}  
}//这个方法没有安全隐患

 

懒汉式

class Single  
{  
	private static Single s = null;  
	private Single(){}  
	public static synchronized Single getInstance()  
	{  
		if (s==null)  
		//-->0  -->1    //懒汉式本身有安全隐患,所以要加同步 synchronized  
		s = new Single();  
		return s;  
	}  
}//虽然这样解决的安全隐患,但是每次获取数据s时都要判断锁,这样效率不高,解决如下: 
  
class Single  
{  
	private static final Single s = null;  
	private Single(){}  
	public static Single getInstance()  
	{  
		if (s==null)  
		{  
			synchronized(Single.class)  
			{  
				if (s==null)  
				{  
					s = new Single();  
				}  
			}  
		}  
		return s;  
	}  
}//可以用这种双重判断的方式解决懒汉式的安全隐患。

 

死锁示例
死锁:常见情景之一:同步的嵌套。
class Ticket implements Runnable  
{  
	private static int num = 100;  
	Object obj = new Object();  
	boolean flag = true;  
	public void run()  
	{  
		if (flag)  
		{  
			while(true)  
			{  
				synchronized(obj)  //同步代码块里面嵌套着同步函数  
				{  
					show();  //同步函数  
				}  
			}  
		}  
		else   
		while(true)  
		this.show();  
	}  
	 
	public static synchronized void show()  //同步函数里面嵌套着同步代码块  
	{  
		synchronized(obj)  //同步代码块  
		{  
			if (num>0)  
			{  
				try{Thread.sleep(10);}catch(InterruptedException e){}  
				System.out.println(Thread.currentThread().getName()+"...sale..."+num--);  
			}  
		}  
	}  
}  
  
  
class SynFunctionLockDemo  
{  
	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(InterruptedException e){}  
		t.flag = false;  
		t2.start();  
	}  
}

 

一种死锁示例
class Test implements Runnable  
{  
	private boolean flag;  
	Test(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 MyLock  
{  
	public static final Object locka = new Object();  
	public static final Object lockb = new Object();  
}  

class DeadLockTest  
{  
	public static void main(String[] args)  
	{  
		Test a = new Test(true);  
		Test b = new Test(false);  
		  
		  
		Thread t1 = new Thread(a);  
		Thread t2 = new Thread(b);  
		t1.start();  
		t2.start();  
	}  
}

 

 

转载于:https://www.cnblogs.com/vector121/p/7474709.html

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值