进程是什么?自我感觉官方定义比较难以理解,于是。。。用自己的话来形容:就是被执行的应用程序,比如:QQ,网易音乐。
线程呢?比如你打开了谷歌浏览器,开了5个网页,这5个网页就可以看作是5个线程。
所以:一个进程可以包含多个线程,一个进程允许好多线程同时访问。
注意:
例如:我们在玩QQ的时候可以听音乐,这是不是cpu一次能执行多个进程呢?答案是否定的,因为:CPU一次只能执行1个程序。而OS会为每个程序分配时间片,则多个程序根据分配的时间片交替进行。由于CPU执行速度非常快,使得所有的程序好像是在”同时”运行一样。
线程的开启
注意:以下俩种方法不论哪种都必须调用Thread的start()方法,才能启动线程
方法一: 继承Thread类,并重写run()方法
举例:
class PrimeThread extends Thread{ //继承Thread类
long minprimer;
public PrimeThread(long minprimer) {
this.minprimer=minprimer;
}
public void run() { //重写run方法
for(int i=0;i<100;i++) {
try {
Thread.sleep(200);//让线程暂停200毫秒
} catch (Exception e) {
// TODO: handle exception
}
System.out.println(Thread.currentThread().getId());
}
}
}
public class TestThreed {
public static void main(String[] args) {
PrimeThread p=new PrimeThread(200);
p.start(); //调用start方法启动线程,自动调用run方法
System.out.println("主线程:"+Thread.currentThread().getId());//Thread.currentThread().getId()获取线程编号
System.out.println("主线程结束");
}
}
方法二: 实现Runnabe接口,并重写run()方法
举例:
class primerThread implements Runnable{
long minprime;
public primerThread(long minprime) {
this.minprime=minprime;
}
@Override
public void run() {
// TODO Auto-generated method stub
for(int i=0;i<100;i++) {
try {
Thread.sleep(200);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getId());
}
}
}
public class TestRun {
public static void main(String[] args) {
new Thread(new primerThread(200)).start();
System.out.println("主线程:"+Thread.currentThread().getId());
System.out.println("主线程结束");
}
}
方法三: 调用线程对象的start()方法来启动该线程。
举例:
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
for(int i=0;i<100;i++) {
try {
Thread.sleep(200);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getId());
}
}
}).start();
System.out.println("主线程:"+Thread.currentThread().getId());
System.out.println("主线程结束");
}
线程同步
当多个线程同时执行(即并发)。多线程并发时,这时会产生资源资源抢占问题,例如很多线程共享同一个对象,这时这个对象称为为临界资源。
那么,为了保证临界资源正确的分配给各个线程,应该保证线程同步。
线程同步的方法:
方法一: 同步代码块:对临界资源对象加锁
synchronized(临界资源对象){
//原子操作
}
线程只有获取临界资源对象的锁标记,才能执行其 后的{}中的代码,并且必须等{}中的所有的代码都执行完成,才释放该对象的锁标记。如果没有获取临界资源的锁标记,则该线程处于等待状态,直到拿到锁标记,才能执行对应的代码。
方法二: 同步方法
synchronized 返回值类型 方法名(形参){
//原子操作
}
举例:卖火车票
火车站有多个窗口可以卖火车票,读个窗口不能售出同一张票。这里我们假设只卖一个乘车区间的票。
首先要有一个车票类
public class Ticket {
private String tno;//车票编号
public String getTno() {
return tno;
}
public void setTno(String tno) {
this.tno = tno;
}
public Ticket(String tno) {
this.tno = tno;
}
}
窗口类:
public class Windows implements Runnable{
//注意:此处用LinkList的原因是:当车票被卖出的时候,车票就要被从车票集合中移除,LinkList底层实现为链表,删除时较为方便,可从头尾移除
private LinkedList<Ticket> tickets;//使用组合的方式将车票与窗口关联起来
public Windows(LinkedList<Ticket> tickets) {
this.tickets = tickets;
}
@Override
public void run() {
//run中使用任何锁都不会达到同步效果,因为有多个window对象
while(true) {
sellTicket(this.tickets);
try {
Thread.sleep(300);
} catch (Exception e) {
// TODO: handle exception
}
}
}
/**
*注意:非static方法使用synchronized ,本质是给当前对象加锁
* static方法使用synchronized,本质是给Class加锁
* 所以此处必须是static方法,否则三个window,会调三个不同的run(),在run()中使用锁是无效的
*/
synchronized public static void sellTicket(LinkedList<Ticket> tickets) {
if(tickets.size() > 0 ) {
Ticket t = tickets.removeLast();
System.out.println(Thread.currentThread().getId() + "卖票一张:" + t.getTno() );
}
}
}
注意:非static方法使用synchronized ,本质是给当前对象加锁,
static方法使用synchronized,本质是给Class加锁
测试类:
public class Test {
public static void main(String[] args) {
LinkedList<Ticket> ts = new LinkedList<>();
for(int i=0;i<100;i++) {
Ticket t = new Ticket(Integer.toString(i));
ts.add(t);
}
//火车票是共享资源,三个线程来竞争资源
new Thread(new Windows(ts)).start();
new Thread(new Windows(ts)).start();
new Thread(new Windows(ts)).start();
}
}