为什么java进程名称都是java

转载

信息流星 2024-10-18 21:32:04

文章标签 为什么java进程名称都是java System 多线程 Test 文章分类 Java 后端开发

一、多线程概述：
1、进程：是一个正在执行中的程序。
每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元。
线程：就是进程中的一个独立的控制单元。线程在控制着进程的执行。一个进程至少有一个线程。

Java VM启动的时候会有一个进程java.exe
该进程中至少有一个线程负责java程序的执行。而且这个线程运行的代码存在于main方法中。

该线程称之为主线程。

扩展：其实jvm启动不止一个线程，还有负责垃圾回收机制的线程。

自定义线程：继承Thread类。

通过对API的查找，java已经提供了对线程这类事物的描述，继承Thread类，覆盖run方法

步骤：
(1).定义类继承Thread
(2).复写Thread类中的run方法
目的：将自定义的代码存储在run方法中，让线程运行。
(3).调用线程的start方法。
该方法有两个作用：启动线程，调用run方法
注解：
发现运行结果每一次都不同。
因为多个线程都获取cpu的执行权。cpu执行到谁，谁就运行。
明确一点，在某一个时刻，只能有一个程序在运行（多核除外）
cpu在做着快速的切换，以达到看上去是同时运行的效果。

Thread类中的run方法，用于存储线程要运行的代码。
(5). 线程有自己默认的名称（可通过this.getname()获得）:Thread-编号，该编号从0开始。
static Thread currentThread():获取当前线程名称
设置线程名称：setName或者构造函数。

实例：
*/

<span style="font-family:KaiTi_GB2312;font-size:18px;">class Demo extends Thread
{
public void run()
{
System.out.println("demo run");
}
}
class ThreadDemo
{
public static void main(String[] args)
{
Demo d=new Demo();//创建好一个线程
d.start();//开启自定义线程
}
}
/*
代码变成如下：结果为


class ThreadDemo
{
public static void main(String[] args)
{
Demo d=new Demo();//创建好一个线程
d.run();//仅仅是对象调用方法，而线程创建了，并没有运行。
}
}
</span>

<span style="font-family:KaiTi_GB2312;font-size:18px;">/*自定义线程名称

*/
class Test extends Thread
{
    Test(String name)//线程的构造方法
{
super(name);
}
public void run()
{
System.out.println(this.getName());//获取当前线程的名称
System.out.println(Thread.currentThread().getName());//获取当前线程的名称，
//currentThread()为static方法，获取当前类的线程对象，可通过类名调用。




}
}
class ThreadDemo
{
public static void main(String[] args)
{
Demo d=new Demo("线程1");//创建好一个线程
d.start();//开启自定义线程
}
}</span>

<span style="font-family:KaiTi_GB2312;font-size:18px;">/*需求：售票的例子
多个窗口同时卖票 
*/
/*示例1*/
class Tickket extends Thread


{
private int tick=100;
public void run()
{
while(true)
{
System.out.println("sale :"+tick--);
}

}
}
class TickDemo
{
public static void main(String[] args)
{/*以下代码会出项编译失败，同一个对象只能开启一次*/
Ticket t1=new Ticket()；//企图创建一个线程，共享100张票
t1.start();
t1.start();
t1.start();
t1.start();




/*以下代码是不对的，因为会各个线程都卖100张票，应该四个线程共享100张票。*/
Ticket t1=new Ticket();
Ticket t2=new Ticket();
Ticket t3=new Ticket();
Ticket t4=new Ticket();
t1.start();
t2.start();
t3.start();
t4.start();
}
}</span>

/*正确方法如下

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

步骤：

1.定义类实现Runnable接口

2，覆盖Runnable接口中的run方法。将线程要运行的代码存放在该run方法中。

3，通过Thread类建立线程对象。

4.将Runnable接口的子类对象作为实际参数传递给Thread类构造函数。

因为，自定义的run方法所属的对象是Runnable接口的子类对象。

所以要让线程去执行指定对象的run方法。就必须明确该run方法所属对象。

5，调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。

实现方式和继承方式有什么区别吗？

实现方式好处：避免了单继承的局限性（如果用继承方式，只能单继承，那么若此类是一个类的子类，而又要继承Thread，单继承性是不允许的）。

在定义线程时，建议使用实现方式。

两种方式区别：

继承Thread：线程代码存放Thread子类run方法中

实现Runnable：线程代码存在接口的子类的run方法中。

<span style="font-family:KaiTi_GB2312;font-size:18px;">class Ticket implements Runnable
{
private int tick=100;
public void run()
{
while(true)
{
System.out.println("sale :"+tick--);
}
}
}
class TicketDemo
{
public static void main(String[] args)
{
Ticket t=new Ticket();


Thread t1=new Thread(t);//创建了一个线程,接受了一个Runnable子类的对象。
Thread t2=new Thread(t);//创建了一个线程
Thread t3=new Thread(t);//创建了一个线程
Thread t4=new Thread(t);//创建了一个线程


t1.start();
t2.start();
t3.start();
t4.start();


}
}</span>

/*通过分析：发现，打印出0，-1，-2等错票

多线程的运行出现了安全问题

问题原因：

当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行

完，另一个线程参与进来执行，导致共享数据的错误。

解决办法：

对多条操作共享数据的语句，只能让一个线程都执行，在执行过程中，

其他线程不可以参与执行。

java对多线程的安全问题提供了专业的解决方式。

1.同步代码块。

synchronized(对象)
{
需要被同步的代码
}

对象如同锁，持有锁的线程可以在同步中执行。

没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有获取锁。

2.同步函数，在需要加锁的函数前加修饰符synchronized，

同步函数的锁是this

3.如果同步函数被静态修饰后，使用的锁是什么呢？

通过验证，发现不再是this，因为静态方法中不可以定义this

静态进内存时，内存中没有类对象，但是一定有该类对应的字节码文件对象，

类名.class.该对象的类型是Class

结论：静态的同步方法，使用的是锁是该方法所在类的字节码文件对象：类名.class

同步的前提：

1.必须要有两个或两个以上的线程。

2.必须是多个线程使用同一锁。

必须保证同步中只能有一个线程在执行。

好处：解决了多线程的安全问题

弊端；多个线程需要判断锁，较为消耗资源。

<span style="font-family:KaiTi_GB2312;font-size:18px;">class Ticket implements Runnable
{
private int tick=100;
Object obj=new Object();
public void run()
{
while(true)
{
synchronized(obj)//同步代码块有两个标志位，当一个线程进来时，标志位由1变为0，此时其他线程进不来，当该线程结束访问时，标志位由0又变为1.
{
if(tick>0)
{try{Thread.sleep(10);}catch(Exception e){};//模拟线程执行权被剥夺情况
System.out.println(Thread.currentThread().getName()+"sale :"+tick--);
}
}
}
}
}
class TicketDemo
{
public static void main(String[] args)
{
Ticket t=new Ticket();


Thread t1=new Thread(t);//创建了一个线程,接受了一个Runnable子类的对象。
Thread t2=new Thread(t);//创建了一个线程
Thread t3=new Thread(t);//创建了一个线程
Thread t4=new Thread(t);//创建了一个线程


t1.start();
t2.start();
t3.start();
t4.start();


}
}</span>

/*多线程-同步函数目的：

需求：

银行有一个金库。

有两个储户分别存300元，每次存100，存3次

该程序是否安全问题？

<span style="font-family:KaiTi_GB2312;font-size:18px;">class Bank
{
private int sum;
/*
方法一：同步代码块
Object obj=new Object();

public  void add(int n)
{
synchronized(obj)
{
sum=sum+n;
try{Thread.sleep(20);}catch(Exception e){}//模拟线程失去执行权时，造成a线程刚做完和，
//还没打印，b线程获得执行权又来做和，这时打印结果不对情况。
System.out.println("sum="+sum);
}
}
}*/
/*方法二：同步代码函数*/
public synchronized void add(int n)
{
sum=sum+n;
try{Thread.sleep(20);}catch(Exception e){}
}
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();


}
}</span>

/*多线程-单例设计模式-懒汉式*/

/*饿汉式*/

<span style="font-family:KaiTi_GB2312;font-size:18px;">class Single
{
private static final Single s=new Single();
private Single(){}
public static Single getInstance()
{
return s;
}


}</span>

/*懒汉式---十分重要*/

//如果把锁加在函数上，使每个线程都要判断锁，低效，所以采用下方式。

<span style="font-family:KaiTi_GB2312;font-size:18px;">class Single
{
private static Single s=null;


private Single(){}
public static Single getInstance()
{
if(s==null)
{
synchronized(Single.class)
{
if(s==null)
s=new Single();
}
}
return s;
}
}</span>

/*多线程-死锁

同步中嵌套同步，而锁不同

<span style="font-family:KaiTi_GB2312;font-size:18px;">/*示例*/
class Test implements Runnable
{
private boolean flag;
Test(boolean flag)
{
this.flag=flag;
}
public void run()
{
if(flag)
{
synchronized(MyLock.locka)
{
System.out.println("if locka");
synchronized(MyLock.lockb)
{
System.ou.println("if lockb");
}
}
}
else
{
synchronized(MyLock.lockb)
{
  System.out.println("else lockb");


synchronized(MyLock.lockaa)
{
System.out.println("else locka");


}
}


}
}
}
class static MyLock
{
static Object locka=new Object();
static Object lickb=new Object();
}
class DeadLockTest
{
public static void main(String[] args)
{


Thread t1=new Thread(new Test(true));
Thread t2=new Thread(new Test(false));
t1.start();
t2.start();
}


}
</span>

线程间通信:

其实就是多个线程在操作同一个资源。但是操作的动作不同

注意：wait（），notify（），notifyAll（）必须都使用在同步中，因为必须要要对持有监视器（锁）
的线程操作。所以要使用在同步中，因为只有同步才具有锁。

为什么这些操作线程的方法要定义在Object类中？
因为这些方法在操作同步中线程时，都必须要标识他们所操作线程持有的锁，
只有同一个锁上的被等待锁，可以被同一锁上notify唤醒。
不可以对不同锁中的线程进行唤醒。
也就是说，等待和唤醒必须是同一个锁。
而锁可以是任意对象，所以可以被任意对象调用的方法定义在Object类中。

实例1：姓名、性别的存与取

<span style="font-family:KaiTi_GB2312;font-size:18px;">class Ras
{
private String name;
private String sex;
private  boolean flag=false; 
public synchronized void set(String name,String sex)
{
if(flag)
try{this.wait();}catch(Exception e){}
this.name=name;
this.sex=sex;
flag=true;
this.notify();//唤醒的是线程池中第一个等待的线程。
}
public  synchronized void out()
{
if(!flag)
try{this.wait();}catch(Exception e){}


System.out.println(name+“……”+sex);
flag=false;
this.notify();


}
}
class Input implements Runnable
{
private Res r;


Input(Res r)
{
this.r=r;
}
public void run()
{int x=0;
while(true)
{
/*synchronized(r)
{

if(x==0)
{
r.set("mike","man");
}
else
{
r.set("丽丽","女女女女")；
}
x=(x+1)%2;
}
}
}
}
class Output implements Runnable
{
Res r;
Output(Res r)
{
this.r=r;
    }


public void run()
{
while(true)
{
r.out();
}

}
}
class InputOutputDemo
{
public static void main(String[] args)
{
Res r=new Ras();
/*Input in=new Input(r);
Output out=new Output(r);
Thread t1=new Thread(in);
Thread t2=new Thread(out);
t1.start();
t2.start();
*/
new Thread(new Input(r)).start();
new Thread(new Output(r)).start();


}
}</span>

/*实例二、线程通信-生产者消费者-当出现多个生产者消费者同时在做这件事时：*/

<span style="font-family:KaiTi_GB2312;font-size:18px;">class Resource
{
private String name;
private int count=1;
private boolean flag=false;
// t1  t2
public synchronized void set(String name)


{
while(flag)//注意此处一定要用while进行标的循环判断，不能用if，被唤醒的线程不进行标志判断。
try{wait();}catch(Exception e){}
this.name=name+"--"+count++;
System.out.println(Thread.currentThread().getName()+"---生产者是"+this.name);
flag=true;
this.notifyAll();//唤醒全部，而不是notify（），防止只唤醒本方，造成全部线程都等待
}
//t3  t4
public synchronized void out()
{
while(!flag)
try{wait();}catch(Exception e){}
System.out.println(Thread.currentThread().getName()+"---消费者是------"+this.name);
flag=false;
this.notifyAll();
}
}
class Producer implements Runnable
{
private Resource res;
Producer(Resource res)
{
this.res=res;
}
public void run()
{
while(true)
{
res.set("商品+");
}
}
}
class Consumer implements Runnable
{
private Resource res;


Consumer(Resource res)


{
this.res=res;
}
public void run()
{
while (true)
{
res.out();
}
}
}
class ProducerConsumerDemo
{
public static void main(String[] args)
{
Resource r=new Resource();
Producer pro=new Producer(r);


Consumer con=new Consumer(r);
Thread t1=new Thread(pro);
Thread t2=new Thread(pro);
Thread t3=new Thread(con);


Thread t4=new Thread(con);


t1.start();
t2.start();
t3.start();
t4.start();
}
}</span>

/*JDK1.5中提供了多线程的新特性

将同步synchronized替换成现实lock操作。

将Object中的wait，notify，notiAll替换成Condition对象。

该对象可以通过Lock锁进行获取。

该事例中，实现了本方只唤醒对方的操。

<span style="font-family:KaiTi_GB2312;font-size:18px;">import java.util.concurrent.locks.*;
class Resource
{
private String name;
private int count=1;
private boolean flag=false;
// t1  t2
private Lock lock=new ReentrantLock();
private Condition condition_pro=lock.newCondition();
private Condition condition_con=lock.newCondition();


public void set(String name)throws InterruptedException


{
lock.lock();//替代了synchronized
try
{
while(flag)//注意此处一定要用while进行标的循环判断，不能用if，被唤醒的线程不进行标志判断。
condition_pro.await();//睡眠生产者
this.name=name+"--"+count++;
System.out.println(Thread.currentThread().getName()+"---生产者是"+this.name);
flag=true;
condition_con.signal();//唤醒消费者
}


finally
{
lock.unlock();
}
}


//t3  t4
public  void out()throws InterruptedException
{
lock.lock();
try
{
while(!flag)
condition_con.await();//await()抛出异常。睡眠消费者
System.out.println(Thread.currentThread().getName()+"---消费者是------"+this.name);
flag=false;
condition_pro.signal();//唤醒生产者
}
finally


{
lock.unlock();//释放锁的动作要执行。
}
}
}
class Producer implements Runnable
{
private Resource res;
Producer(Resource res)
{
this.res=res;
}
public void run()
{
while(true)
{
try
{
res.set("商品+");
}
catch (InterruptedException e)
{
}

}
}
}
class Consumer implements Runnable
{
private Resource res;


Consumer(Resource res)


{
this.res=res;
}
public void run()
{
try
{
res.out();
}
catch (InterruptedException e)
{
}

}
}
class ProducerConsumerDemo
{
public static void main(String[] args)
{
Resource r=new Resource();
Producer pro=new Producer(r);


Consumer con=new Consumer(r);
Thread t1=new Thread(pro);
Thread t2=new Thread(pro);
Thread t3=new Thread(con);


Thread t4=new Thread(con);


t1.start();
t2.start();
t3.start();
t4.start();
}
}</span>

/*多线程-停止线程

stop方法已经过时

如何停止线程呢？

只有一种，run方法结束。

开启多线程运行，运行代码通常是循环结构的。

只要控制住循环，就可以让run方法结束，也就是线程结束。

特殊情况：

当线程处于冻结状态时，就不会读取到标记。那么线程就不会结束。

中断线程interrupt：清除线程的冻结（wait，sleep等）状态，不是结束线程。

当没有指定的方式让冻结的线程恢复到运行状态时，这时需要对冻结进行清除，强制让线程恢复到运行状态中来，

这样就可以操作标让线程结束。

Thread类提供了该方法 interrupt（）方法。

守护线程：setDaemon

1，将t设为守护线程即后台线程，

好处是：当主线程结束时该守护线程自动结束不必再手动interrupt中断线程。

2.该方法必须在启动线程前调用。

<span style="font-family:KaiTi_GB2312;font-size:18px;">class StopThread implements Runnable
{
private boolean flag=true;
public synchronized void run()
{
while(flag)
{
try
{
wait();
}
catch (InterruptedException e)//捕获主线程中抛出的InterruptedException异常。
{
System.out.println(Thread.currentThread().gerName()+"---Exception");
flag=false;
}
System.out.println(Thread.currentThread().getName()+"---run over");
}

}
class StopThreadDemo
{
public static void main(String[] args)
{
StopThread st=new stopThread();
Thread t1=new Thread(st);
Thread t2=new Thread(st);


/*
t1.setDaemon(true);
t2.setDaemon(true);将t1，t2设为守护线程即后台线程，
好处是：当主线程结束时该守护线程自动结束不必再手动interrupt中断线程。
*/
t1.start();
t2.start();
int num=0;
while(true)
{
if(num++==60)
{
t1.interrupt();//线程中断，并抛出InterruptedException异常。
t2.interrupt();
break;
}
System.out.println(Thread.currentThread().getName()+"---"+num);

}
System.out.println("over");
}
}</span>

/*t.join()方法：t.join()方法：join可以用来临时加入线程执行，其他线程要等到这个心加入的线程执行完，才能开始。

<span style="font-family:KaiTi_GB2312;font-size:18px;">/*示例*/
class Demo implements Runnable
{
public void run()
{
for(int x=0;x<=70;x++)


{
System.out.println(Thread.currentThread().getName()+"--"+x);
}
}
}
class JoinDemo
{
public static void main(String[] args)
{
Demo d=new Demo();
Thread t1=new Thread(d);
Thread t2=new Thread(d);
t1.start();
t2.start();
t1.join();
for(int x=0;x<=80;x++)


{
System.out.println(Thread.currentThread().getName()+"--"+x);
}
    System.out.println("over");
}
}</span>

/*优先级:

1.示例：setPriority(Thread.MAX_PRIORITY)

2.Thread.yield()方法：暂停当前正在执行的线程对象，并执行其他线程。yield:屈服投降的意思。

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。