自定义线程
方式:
方式一: 1.自定义一个类继承Thread方法
2.重写Thread类的run方法,把自定义线程的任务代码写在run方法中
3.创建Thread的子类对象,并且调用start方法开启线程。
(线程一旦开启,就会直接调用run方法,不可直接在main中调用)
方式二: 1.自定义一个类实现Runnable接口;
2.实现Runable接口的run方法,把自定义线程的任务写在run方法上。
3.创建Runable实现类对象。
4.创建Thread类对象,并把Runnable的实现类对象作为实参传递。
5.调用Thread对象的start方法开启线程。
线程的状态:
1.创建:新创建了一个线程对象。
2.可运行:线程对象创建后,其他线程调用了该对象的start()方法。该状
态的线程位于可运行线程池中,变得可运行,等待获取cpu的执行权。
3.运行:就绪状态的线程获取了CPU执行权,执行程序代码。
4.阻临时塞: 阻塞状态是线程因为某种原因放弃CPU使用权,暂时停止
运行。直到线程进入就绪状态,才有机会转到运行状态。
5.死亡:线程执行完它的任务时。
常用线程的方法:
1.Thread(String name) 初始化线程的名字
2.getName() 返回线程的名字
3.setName(String name) 设置线程对象名
4.sleep(int Millis) 线程睡眠指定的毫秒数。
5.getPriority() 返回当前线程对象的优先级 默认线程的优先级是5
6.setPriority(int newPriority) 设置线程的优先级
虽然设置了线程的优先级,但是具体的实现取决于底层的操作系统的
实现(最大的优先级是10 ,最小的1 , 默认是5)。
7.currentThread() 返回CPU正在执行的线程的对象
样例代码:
class TalkThread extends Thread{
public void run()
{
int j=0;
while(j<50)
{
j++;
System.out.println("正在聊天");
}
}
}
class VedioThread extends Thread{
public VedioThread(String name)
{
super(name);
}
public void run() {
int i=0;
while(i<50)
{
i++;
System.out.println("在视屏。。。。。。");
}
}
}
public class Demo3 {
public static void main(String[] args) {
TalkThread ss = new TalkThread();
ss.start();
ss.setName("小号");
VedioThread hh = new VedioThread("nihao");
hh.start();
hh.setPriority(10);
}
}
class SaleTicket implements Runnable {
int num=50;
public void run(){
while(true){
synchronized("锁"){
if(num>0){
System.out.println(Thread.currentThread().getName()+"卖" + num);
num--;
}
else {
System.out.println("卖完。。。");
break;
}
}
}
}
}
public class Demo3 {
public static void main(String[] args) {
SaleTicket dd = new SaleTicket();
Thread aa = new Thread(dd,"小明");
Thread bb = new Thread(dd,"小云");
Thread cc = new Thread(dd,"小华");
aa.start();
bb.start();
cc.start();
}
}
线程同步
同步代码块:
synchronized(锁对象){
需要同步的代码;
}
注意的细节:
1.任何一个对象都可以作为锁对象;
2.在同步代码块中调用sleep方法,并不是释放锁对象;
3.只有真正存在线程安全时才能用同步代码块,否则会降低效率;
4.多线程操作的锁对象必须是唯一共享的。
样例代码:
class SaleTicket extends Thread{
static int num = 50;
public SaleTicket(String name)
{
super(name);
}
public void run() {
synchronized("锁对象"){
while(true)
{
if(num>0){
System.out.println(Thread.currentThread().getName()+" sale "+num);
try{
Thread.sleep(100);
}catch(InterruptedException e){
e.printStackTrace();
}
num--;
}
else{
System.out.println(Thread.currentThread().getName()+"票已卖完。。");
break;
}
}
}
}
}
public class Demo1 {
public static void main(String[] args) {
SaleTicket aa = new SaleTicket("窗口1");
SaleTicket bb = new SaleTicket("窗口2");
SaleTicket cc = new SaleTicket("窗口3");
aa.start();
bb.start();
cc.start();
}
}
同步函数:
用synchronized修饰一个函数
注意细节:
1.一个非静态的同步函数的锁对象是this对象,静态同步函数的锁对象是
当前函数所属类的字节码对象。
2.同步函数的锁对象是固定的。
死锁:
存在多个线程和多个共享资源时易产生死锁
样例代码:
class DeadSuo extends Thread{
public DeadSuo(String name)
{
super(name);
}
public void run() {
if("丈夫".equals(Thread.currentThread().getName())){
synchronized("遥控器"){
System.out.println("丈夫拿到遥控器,准备拿电池。。");
synchronized("电池"){
System.out.println("丈夫拿到了电池,打开了电视。。");
}
}
}else if("妻子".equals(Thread.currentThread().getName())){
synchronized("电池"){
System.out.println("妻子拿到电池,准备拿遥控器。。");
synchronized("遥控器"){
System.out.println("妻子了拿遥控器,打开了电视。。");
}
}
}
}
}
public class Demo1 {
public static void main(String[] args) {
DeadSuo aa = new DeadSuo("丈夫");
DeadSuo bb = new DeadSuo("妻子");
aa.start();
bb.start();
}
}
wait 和 notify 方法:
1.wait 和 notify 方法都属于 Obeject 对象,都必须要在同步代码块或同步函数中使用,都必须用锁对象调用。
2.wait:告诉当前线程放弃执行权,并放弃监视器(锁)并进入阻塞状
态(在线程池中等待),直到其他线程持有获得执行权,并持有了相同的监视器(锁)并调用notify为止。
3.notify:唤醒持有同一个监视器(锁)中调用wait的第一个线程,例如,餐馆有空位置后,等候就餐最久的顾客最先入座。注意:被唤醒的线程是进入了可运行状态。等待cpu执行权。
4.notifyAll:唤醒持有同一监视器中调用wait的所有的线程。
样例代码:
class Product{
String name;
double price;
boolean flag=false;
}
class Productor extends Thread{
Product p;
public Productor(Product p){
this.p = p;
}
public void run(){
int i=0;
while(true){
synchronized(p){
if(p.flag==false){
if(i%2==0){
p.name = "苹果";
p.price= 2.0;
}
else{
p.name = "香蕉";
p.price = 6.0;
}
p.flag=true;
System.out.println("生产了"+p.name+"价格"+p.price);
i++;
p.notify();
}
else{
try {
p.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
class Consumer extends Thread{
Product p;
public Consumer(Product p){
this.p = p;
}
public void run(){
while(true){
synchronized(p){
if(p.flag==true){
System.out.println("消费了"+p.name+"价格"+p.price);
p.flag=false;
p.notify();
}
else {
try {
p.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
public class Demo1 {
public static void main(String[] args) {
Product p = new Product();
Productor aa = new Productor(p);
Consumer bb = new Consumer(p);
aa.start();
bb.start();
}
}
守护线程(后台线程):
1.一个线程默认都不是守护线程。
2.在一个线程中只剩下守护线程时,守护线程也会死亡。
样例代码:
public class Demo1 extends Thread{
public Demo1(String name){
super(name);
}
public void run(){
for(int i=0; i<100; i++){
System.out.println("更新包目前下载"+i+"%");
if(i==100) {
System.out.println("更新完毕");
}
try{
Thread.sleep(1000);
}catch(InterruptedException e){
e.printStackTrace();
}
}
}
public static void main(String[] args)
{
Demo1 d = new Demo1("后台线程");
System.out.println("是守护线程吗?" + d.isDaemon());
d.start();
for(int i=0; i<100; i++){
System.out.println(Thread.currentThread().getName()+":" +i);
}
}
}
join 线程:
样例代码:
class Mon extends Thread{
public void run(){
System.out.println("妈妈炒菜没酱油");
System.out.println("妈妈让儿子买酱油。。");
Son r = new Son();
r.start();
try {
r.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("妈妈炒菜没酱油");
}
}
class Son extends Thread{
public void run(){
System.out.println("儿子买酱油");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public class Demo1{
public static void main(String[] args)
{
Mon d = new Mon();
d.start();
}
}