学习java的第22天

多线程

并发与并行

•并发：指两个或多个事件，在同一个时间段内发生
•并行：这两个或多个事件在同一时刻发生(同时发生)。

线程与进程

•进程：是指一个内存中运行的应用程序，每个程序都有一个独立的内存空间，一个应用程序可以同时运行，多个进程，进程也是程序的一次执行过程，是系统运行程序的基本单位，罕见的女朋友系统运行一个程序，即是一个进程，从创建运行到消亡的过程。
•线程：县城市进程中的一个执行单元，负责当前进程中程序的执行一个进程中，至少有一个线程，一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
简而言之：一个程序运行后，至少有一个进程，一个进程中可以包含多个线程。

Thread 类和Runnable接口

1.通过继承Thread类来创建线程
package Demo01;
/*

• 主线程 执行main（）方法的线程

• 单线程程序：只有一个线程在执行，从头到尾。
  */
  public class Demo01MAainThread {
  public static void main(String[] args) {
  Person p1=new Person(“小郑”);
  p1.run();

   //System.out.println(0/0);
   
   Person p2=new Person("小何");
   p2.run();
  

  }
  }

package Demo01;
/*
*

• 实现步骤：
• 1.创建一个Thread类的子类
• 2.在Thread子类中重写run方法，施智线程任务（干什么）
• 3.创建Thread子类的对象
• 4.调用Thread类中的方法START来启动程序，执行run方法
  */
  public class Demo01Thread {
  public static void main(String[] args) {
  //3.创建Thread子类对象
  MyThread mt =new MyThread();
  //4.调用start方法
  mt.start();
  for(int i=0;i<20;i++) {
  System.out.println(“主线程；+i”);
  //if(i==10);
  //System.out.println(0/0);
  }
  }

}

package Demo01;
/*

• 1.创建子类

*/
public class MyThread extends Thread{
//2.重写run方法
@Override
public void run() {

	for(int i=0;i<20;i++){
		System.out.println("子线程："+i);
		
	}
}

}

package Demo01;

public class Person {
private String name;

public String getName() {
	return name;
}

public void setName(String name) {
	this.name = name;
}
 public Person() {
 }
 public Person(String name) {
	 this.name=name;
 }
 public void run() {
	 for(int i=0;i<20;i++)
	 {
		 System.out.println(name+"-->"+i);
	 }
 }
 }

package Demo02;

import Demo01.MyThread;
/*

• 实现步骤：

• 1.创建一个Thread类的子类

• 2.在Thread子类中重写rub方法，设置任务（干什么）

• 3.创建Thread子类的对象

• 4.调用Thread类中的方法start来启动线程，执行run方法
  */
  public class Demo01Thread {
  public static void main(String[] args) {
  //3.创建Thread子类对象
  MyThread mt =new MyThread();
  //4.调用start方法
  mt.start();//子线程1
  new MyThread().start();//子线程2

   new MyThread().start();//子线程3
   new MyThread().start();//子线程4
  

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

package Demo02;

public class Demo02ThreadSetName {
public static void main(String[] args) {
MyThreadName mt=new MyThreadName(“小郑”);
mt.start();
new MyThreadName(“小何”).start();

}

}

package Demo02;
//1.创建Thread子类
public class MyThread {
//2.重写run方法
public void run() {

	//String name=getName();
	//String.out.println("run: "+name);
	
	System.out.println("子"+Thread.currentThread().getName());
	}

}

package Demo02;

public class MyThreadName extends Thread{
public MyThreadName() {}
public MyThreadName(String name) {
super(name);//把线程的名字传递给父类，让父类Thread给子类线程起一个名字
}
@Override
public void run() {
//String name=getname();
//System.out.println(“run:”+name);
System.out.println(“子:”+Thread.currentThread().getName());
}

}
终止线程方法

package Demo03;

public class Demo03Sleep {
public static void main(String[] args) {
for(int i=1;i<60;i++) {
System.out.println(i);
try {
Thread.sleep(1000);
}catch (InterruptedException e) {
e.printStackTrace();
}
}
}

}

2.通过实现Runnable来创建线程

package Demo04;
/*

• 实现runnable接口多线程的好处：

• 1.避免了单继承的局限性

• 2.增强了程序的扩展性，降低了程序的耦合性
  */
  public class Demo04Runnable {
  public static void main(String[] args) {
  //3.创建一个runnable接口的实现类对象
  //RunnableImpl run=new RunnableImpl();
  //4.创建Thread对象，构造方法中传递Runnable接口实现类对象
  //Thread t=new Thread(run);
  //5.调用Thread类中的start方法，启动子线程
  Thread t=new Thread(new Runnablelmpl2());
  t.start();
  for(int i=0;i<20;i++) {
  System.out.println(Thread.currentThread().getName()+"–>"+i);
  }

  }

}

package Demo04;
//1.创建一个runnable接口的实现类
public class Runnablelmpl implements Runnable{
//2.在实现类中，重写runnable中的run方法，设置线程任务
@Override
public void run() {
for(int i=0;i<20;i++) {
System.out.println(Thread.currentThread().getName()+"–>"+i);
}
}

}

package Demo04;

public class Runnablelmpl2 implements Runnable {
@Override
public void run() {
for(int i=0;i<20;i++) {
System.out.println(“Helloworld–>”+i);
}
}

}

package Demo05ThreadSafe;

public class Demo01Ticket {
public static void main(String[] args) {
RunnableImpl run=new RunnableImpl();
Thread t0=new Thread(run);
Thread t1=new Thread(run);
Thread t2=new Thread(run);

	t0.start();
	t1.start();
	t2.start();
}

}

synchronized关键字及线程同步
package Demo05ThreadSafe;

public class RunnableImpl implements Runnable{

private int ticket=100;
Object obj=new Object();

// @Override

public void run() {
	while(true) {
		synchronized(obj) {
	if(ticket>0) {
		try {
			Thread.sleep(10);
		}catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
		ticket--;
		
	}

}

	}}}