多线程（一）

于 2019-08-22 17:44:26 发布
阅读量109 收藏 1
点赞数
分类专栏： Java基础 文章标签： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_22193699/article/details/100003590
版权

 

进程

进程是出于运行过程中的的程序，并且具有一定的独立功能，进程是系统进行资源分配和调度的一个独立单位。

三大特征：

  1. 独立性
  2. 动态性
  3. 并发性

并发：同一时刻只能有一条指令执行，但是多个进程指令被快速轮转，所以宏观上看起来是多个进程同时执行的，

并行：同一时刻，多条指令在多个处理器上同时执行，同时处理多个任务

线程

线程可拥有自己的堆栈，程序计数器，局部变量，但是不拥有系统资源，线程间共享进程的所有资源，独立运行，抢占式执行

如果把上课的过程比作进程，把老师比作CPU，那么可以把每个学生比作每个线程，所有学生共享这个教室(也就是所有线程共享进程的资源)，上课时学生A向老师提出问题，老师对A进行解答，此时可能会有学生B对老师的解答不懂会提出B的疑问(注意：此时可能老师还没有对A同学的问题解答完毕)，此时老师又向学生B解惑，解释完之后又继续回答学生A的问题，同一时刻老师只能向一个学生回答问题(即：当多个线程在运行时，同一个CPU在某一个时刻只能服务于一个线程，可能一个线程分配一点时间，时间到了就轮到其它线程执行了，这样多个线程在来回的切换)
 ———————————————— 
摘自：https://blog.csdn.net/vbirdbest/article/details/81282163

线程的3种创建方式

  1. 继承Thread类
  2. 实现Runnable接口
  3. 使用Callable和Future

 

  • 继承Thread类

public class ThreadDemo extends Thread{
	//1.  定义Thread类的子类，并重写run()方法,该run()方法就代表了线程需要完成的任务，被称为线程执行体
	@Override
	public void run() {
		for(int i = 0; i < 50; i++) {
			//继承Thread类实现多线程可以使用this代表当前线程，也可以调用Thread.currentThread()，
			//实现Runnable接口只能用Thread.currentThread()
			//System.out.println(Thread.currentThread().getName() + "\t" + "\t" + i);
			System.out.println(this.getName()+ "\t" + i);

		}
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		for (int i = 0; i < 50; i++) {
			System.out.println(Thread.currentThread().getName() + "\t" + "\t" + i);
			if(i == 20) {
	//2. 创建Thread子类的实例，即创建了线程对象
				ThreadDemo thread1 = new ThreadDemo();
	//3. 调用线程对象的start()方法来开启线程
				thread1.start();
				new ThreadDemo().start();
			}
		}
		

	}

}

 

  • 实现Runnable接口


public class ThreadDemo1 implements Runnable{
	private int i;
	@Override
	public void run() {
		// TODO Auto-generated method stub
		for( ; i < 50; i++) {
			//实现Runnable接口只能用Thread.currentThread(),不能用this
			System.out.println(Thread.currentThread().getName() + "\t" + "\t" + i);

		}
		
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		for (int i = 0; i < 50; i++) {
			System.out.println(Thread.currentThread().getName() + "\t" + "\t" + i);
			if(i == 20) {
	//创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，即线程对象
				ThreadDemo1 thread = new ThreadDemo1();
	//3. 调用线程对象的start()方法来开启线程
				new Thread(thread, "线程11").start();
				new Thread(thread, "线程22").start();
				Thread th = new Thread(thread, "线程33");
				th.start();
				System.out.println("xianchengming:" + th.getName());//xianchengming:线程33
			}
		}
	}

	

}

其他形式

public class Thread1 {
    public static void main(String[] args) {
        // 匿名内部类------------------1
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        }).start();



     

        // Runnable是函数式接口，所以可以使用Lamda表达式形式------------------2
        Runnable runnable = () -> {System.out.println(Thread.currentThread().getName() );};
        new Thread(runnable).start();
    }
}
  • 使用Callable和Future   暂时不讲

 

两种方式的比较

Runnable相对于Thread的优劣势为：

  1. 多个线程共享一个target对象，适合多个程序代码相同的线程处理同一资源
  2. 可以避免Java的单继承带来的局限
  3. Runnable必须使用Thread.currentThread()方法来获取当前对象，而Thread可以直接使用this

以下以售卖火车票来举例说明------多个线程共享一个target对象，适合多个程序代码相同的线程处理同一资源



public class Ticket extends Thread{
	private int ticket = 50;
	private String name;
	public Ticket(String name) {
		// TODO Auto-generated constructor stub
		this.name = name;
	}
	@Override
	public void run() {
		while(true) {
			if(ticket > 0) {
				System.out.println(name + "正在发售第 " + ticket-- + "张票");
			}else {
				break;
			}
		}
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//创建四个线程对象
		Ticket t1 = new Ticket("窗口 1 ");
		Ticket t2 = new Ticket("窗口 2 ");
		Ticket t3 = new Ticket("窗口 3 ");
		t1.start();
		t2.start();
		t3.start(); 
		new Ticket("窗口 4 ").start();;
	}

}

​窗口 2 正在发售第 50张票
窗口 2 正在发售第 49张票
窗口 1 正在发售第 50张票
窗口 2 正在发售第 48张票
窗口 2 正在发售第 47张票
窗口 4 正在发售第 50张票
窗口 2 正在发售第 46张票
窗口 2 正在发售第 45张票
窗口 2 正在发售第 44张票
窗口 3 正在发售第 50张票
窗口 3 正在发售第 49张票
窗口 3 正在发售第 48张票
窗口 3 正在发售第 47张票
窗口 3 正在发售第 46张票
窗口 3 正在发售第 45张票
窗口 3 正在发售第 44张票
窗口 1 正在发售第 49张票
窗口 3 正在发售第 43张票
窗口 2 正在发售第 43张票
窗口 4 正在发售第 49张票
窗口 2 正在发售第 42张票
窗口 3 正在发售第 42张票
窗口 1 正在发售第 48张票
​

每个窗口都输出了50次，与实际要求不符合，因为每次创建Ticket对象时，ticket都被Ticket对象重新拥有

 

package shangtang;

public class Ticket1 implements Runnable{
	private int ticket = 10;
	@Override
	public void run() {
		// TODO Auto-generated method stub
		while(true) {
			
			if(ticket > 0) {
				try {
					Thread.sleep(0);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			System.out.println(Thread.currentThread().getName() + "正在发售第 " + ticket-- + "张票");
			}else {
				break;
			}
		}
		
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Ticket1 t = new Ticket1();
		Thread t1 = new Thread(t, "窗口 1 ");
		Thread t2 = new Thread(t, "窗口 2 ");
		Thread t3 = new Thread(t, "窗口 3 ");
		t1.start();
		t2.start();
		t3.start();
		new Thread(t, "窗口 4 ").start();;

	}

	

}

窗口 1 正在发售第 10张票
窗口 2 正在发售第 7张票
窗口 3 正在发售第 8张票
窗口 4 正在发售第 9张票
窗口 1 正在发售第 5张票
窗口 2 正在发售第 6张票
窗口 3 正在发售第 4张票
窗口 4 正在发售第 3张票
窗口 2 正在发售第 1张票
窗口 1 正在发售第 2张票
窗口 3 正在发售第 0张票

如上满足要求，但是多次运行后会出现售票0或者负数问题，此处说明线程不安全，某一时刻一个线程访问某一资源时，其他线程也在访问，造成线程不安全，线程安全要求某一时刻只能由一个线程访问某一资源

窗口 1 正在发售第 10张票
窗口 3 正在发售第 8张票
窗口 4 正在发售第 9张票
窗口 2 正在发售第 10张票
窗口 4 正在发售第 7张票
窗口 3 正在发售第 6张票
窗口 1 正在发售第 7张票
窗口 2 正在发售第 7张票
窗口 1 正在发售第 5张票
窗口 3 正在发售第 4张票
窗口 2 正在发售第 3张票
窗口 4 正在发售第 5张票
窗口 4 正在发售第 1张票
窗口 1 正在发售第 0张票
窗口 2 正在发售第 2张票
窗口 3 正在发售第 -1张票

要解决这个问题需要用到同步，同步是指多个操作在同一时间段内只能由一个线程进行，其他的线程要想执行必须等待此线程结束。

  • 同步代码块

synchronized (同步对象) {

需要同步的代码;

}

 

 

package shangtang;

public class Ticket1 implements Runnable{
	private int ticket = 15;
	@Override
	public void run() {
		// TODO Auto-generated method stub
		while(true) {
		synchronized(this) {
			if(ticket > 0) {
				try {
					Thread.sleep(10);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			System.out.println(Thread.currentThread().getName() + "正在发售第 " + ticket-- + "张票");
			}else {
				break;
			}
		}
		}
		
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Ticket1 t = new Ticket1();
		Thread t1 = new Thread(t, "窗口 1 ");
		Thread t2 = new Thread(t, "窗口 2 ");
		Thread t3 = new Thread(t, "窗口 3 ");
		t1.start();
		t2.start();
		t3.start();
		new Thread(t, "窗口 4 ").start();;

	}

	

}

窗口 1 正在发售第 15张票
窗口 1 正在发售第 14张票
窗口 2 正在发售第 13张票
窗口 2 正在发售第 12张票
窗口 2 正在发售第 11张票
窗口 2 正在发售第 10张票
窗口 2 正在发售第 9张票
窗口 2 正在发售第 8张票
窗口 2 正在发售第 7张票
窗口 2 正在发售第 6张票
窗口 2 正在发售第 5张票
窗口 2 正在发售第 4张票
窗口 2 正在发售第 3张票
窗口 3 正在发售第 2张票
窗口 3 正在发售第 1张票
  • 同步方法

实现与同步代码块相同的功能，被synchronized修饰的方法在某一时刻只允许一个线程访问，访问该方法的其他线程都会发生阻塞，知道当前线程访问完毕，其他线程才有机会访问该方法。

权限修饰符 synchronized 返回值类型 方法名 ([参数 1,...]) {
    需要同步的代码;
}


public class Ticket2 implements Runnable{
	private int ticket = 12;
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Ticket2 t = new Ticket2();
		new Thread(t, "窗口 1 ").start();
		new Thread(t, "窗口 2 ").start();
		new Thread(t, "窗口 3 ").start();
		new Thread(t, "窗口 4 ").start();

	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		while(true) {
			saleTicket();
			if(ticket <= 0)
				break;
		}
		
	}
	private synchronized void saleTicket() {
		if(ticket > 0) {
			try {
				Thread.sleep(10);
				System.out.println(Thread.currentThread().getName() + " 正在发售第 " + ticket-- + "张票");
			} catch (InterruptedException e) {
				// TODO: handle exception
				e.printStackTrace();
			}
		}
	}

}

窗口 1  正在发售第 12张票
窗口 1  正在发售第 11张票
窗口 4  正在发售第 10张票
窗口 4  正在发售第 9张票
窗口 4  正在发售第 8张票
窗口 4  正在发售第 7张票
窗口 4  正在发售第 6张票
窗口 4  正在发售第 5张票
窗口 4  正在发售第 4张票
窗口 4  正在发售第 3张票
窗口 4  正在发售第 2张票
窗口 4  正在发售第 1张票

未完待续.....

豆花二哥
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值