2015/8/5/抢锁/线程/JFrame

最新推荐文章于 2023-02-22 02:37:38 发布

ForrestL

最新推荐文章于 2023-02-22 02:37:38 发布

阅读量503

点赞数

分类专栏： JAVA 文章标签： java

本文链接：https://blog.csdn.net/ForrestL/article/details/47303033

版权

JAVA 专栏收录该内容

22 篇文章 0 订阅

订阅专栏

synchronized

简单线程

线程与JFrame的结合

synchronized

1.synchronized锁的对象一般为类的对象，不能用太简单的形式例如Integer和boolean，因为过于简单会导致锁错误
2.synchronized的方法锁的对象是：调用该方法的对象
3.为避免抢锁现象的发生，常用Object类中wait和notify方法

简单例子

这里写图片描述

package com.baidu.producer;
public class Test {
    public static void main(String[] args) {
        Product product=new Product();
        Thread producer=new Thread(new Producer(product));
        Thread consumer=new Thread(new Consumer(product));
        producer.start();
        try {
            Thread.sleep(500);
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }
        consumer.start();
    }
}
package com.baidu.producer;
public class Product {
    private int num=0;

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }


    public synchronized void consumer () {  //锁的对象是：调用该方法的对象
        System.out.println("消费者抢到了锁");
        if (getNum() != 0) {                //如果有商品就消费
            System.out.println("消费产品");
            try {                           //消费耗时
                Thread.sleep(2000);
            } catch (InterruptedException e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
            }
            setNum(0);                      //消费完成，将商品清零
            /*
             * 唤醒生产者之后，生产者和消费者又开始抢锁，因此为了保持先生产后消费
             * 的逻辑理论，让消费者重新进入循环之后等待500ms让生产者抢到锁
             */
            notify();                       //唤醒等待的生产者
        }
    }
    public synchronized void producer() {
        System.out.println("生产者抢到了锁");
        if (getNum()==0) {                   //判断有无商品，有就跳过，没有就执行
            System.out.println("生产产品");
            try {                            //生产耗时
                Thread.sleep(3000);
            } catch (InterruptedException e1) {
                e1.printStackTrace();
            }
            setNum(1);                      //生产出了产品
            try {
                wait();                     //等待消费者消费
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

package com.baidu.producer;

public class Producer implements Runnable{
    Product pro;
    public Producer(Product pro){
        this.pro=pro;
    }
    @Override
    public void run() {
        while(true){
            pro.producer();
        }
    }

}
package com.baidu.producer;

public class Consumer implements Runnable {
    Product pro;

    public Consumer(Product pro) {
        this.pro = pro;
    }

    @Override
    public void run() {
        while (true) {
            try {                                //为了让生产者抢到锁，让消费者休息0.5s
                Thread.sleep(500);
            } catch (InterruptedException e1) {
                e1.printStackTrace();
            }
            pro.consumer();
        }
    }

}

线程的一般例子

1.线程公用的对象可以是数据也可以是端口
2.一般线程公用是一个类型的话，通常可以用构造方法来调用对象

package com.baidu.dialogue;

import java.io.IOException;
import java.net.Socket;
import java.net.UnknownHostException;

public class MyClient {
    public static void main(String[] args) {
        try {
            System.out.println("客户端连接");
            Socket socket=new Socket("192.168.0.113", 8080); //创建一个流套接字并将其连接到指定 IP 地址的指定端口号
            Thread read=new Thread(new MyRead(socket));      //创建线程
            Thread write=new Thread(new MyWrite(socket));    //创建线程
            read.start();                                    //线程启动
            write.start();
        } catch (UnknownHostException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}
package com.baidu.dialogue;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

public class MyServer {
    public static void main(String[] args) {
        try {
            System.out.println("服务端启动");
            ServerSocket server=new ServerSocket(8080);  //创建绑定到特定端口的服务器套接字
            Socket socket=server.accept();               //侦听并接受到此套接字的连接
            Thread read=new Thread(new MyRead(socket));  //创建线程
            Thread write=new Thread(new MyWrite(socket));//执行接收和写入端口的操作
            read.start();
            write.start();                               //线程启动
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}
package com.baidu.dialogue;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.Socket;

public class MyRead implements Runnable {
    private Socket socket;
    public MyRead(Socket socket) {
        this.socket = socket;
    }
    @Override
    public void run() {
        BufferedReader br=null;
        try {
            InputStream is = socket.getInputStream();
            br = new BufferedReader(new InputStreamReader(is));
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        while (true) {
            try {
                String line=br.readLine();
                System.out.println("嘿嘿"+line);
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

    }

}
package com.baidu.dialogue;

import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.Socket;
import java.util.Scanner;

public class MyWrite implements Runnable{
    private Socket socket;
    public MyWrite(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        BufferedWriter bw=null;
        try {
            OutputStream os=socket.getOutputStream();
            bw=new BufferedWriter(new OutputStreamWriter(os));
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        Scanner scanner=new Scanner(System.in);
        while(true){
            String words=scanner.next();
            try {
                bw.write(words+"\n");
                bw.flush();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

    }

}

JFrame

1.先在电脑上装上WindowsBuilder插件
这里写图片描述

package com.baidu.imSwing;

import java.awt.BorderLayout;
import java.awt.EventQueue;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;
import javax.swing.JButton;
import java.awt.event.ActionListener;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.awt.event.ActionEvent;
import javax.swing.JTextField;
import javax.swing.JTextArea;

public class MyServer extends JFrame {

    private JPanel contentPane;
    private Socket socket;
    private JTextArea textArea;

    /**
     * Launch the application.
     */
    public static void main(String[] args) {
        EventQueue.invokeLater(new Runnable() {
            public void run() {
                try {
                    MyServer frame = new MyServer();
                    frame.setVisible(true);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }

    /**
     * Create the frame.
     */
    public MyServer() {
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setBounds(100, 100, 451, 445);
        contentPane = new JPanel();
        contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
        setContentPane(contentPane);
        contentPane.setLayout(null);

        JButton btnNewButton = new JButton("启动服务");
        btnNewButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                try {
                    System.out.println("服务器启动");
                    ServerSocket server=new ServerSocket(8080);               //创建服务端，监听8080端口
                    socket=server.accept();                                   //侦听并接受到此套接字的连接
                    System.out.println("有连接进入服务器");
                    Thread myRead=new Thread(new MyServerRead(MyServer.this));//创建新的线程对象，作用是接收发送过来的数据
                    myRead.start();                                           //启动线程
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
            }
        });
        btnNewButton.setBounds(27, 10, 243, 70);
        contentPane.add(btnNewButton);

        JButton btnNewButton_1 = new JButton("发送");
        btnNewButton_1.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent arg0) {
                write();                                                    //调用write方法，点击button就发送数据
            }
        });
        btnNewButton_1.setBounds(306, 340, 93, 57);
        contentPane.add(btnNewButton_1);

        textArea= new JTextArea();
        textArea.setBounds(27, 340, 243, 57);
        contentPane.add(textArea);
    }
    public void read(){
        try {
            InputStream is=socket.getInputStream();                         //创建一个输入流
            BufferedReader br=new BufferedReader(new InputStreamReader(is));//创建一个输入缓冲区域缓冲字符流
            String line=br.readLine();                                      //读一行文本
            System.out.println("客户端："+line);

        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
    public void write(){
        OutputStream os;
        try {
            os = socket.getOutputStream();                                  //创建一个输出流
            BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(os));//创建一个有输出缓冲区的输出字符流
            String words=textArea.getText();                                //从文本框中得到文本放入words中
//          System.out.println("服务端输出");
            bw.write(words+"\n");                                           //将得到的文本写入包中发送出去    
            textArea.setText("");                                           //清空文本
            bw.flush();                                                     //冲刷
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
}
package com.baidu.imSwing;

import java.awt.BorderLayout;
import java.awt.EventQueue;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;
import javax.swing.DefaultListModel;
import javax.swing.JButton;
import java.awt.event.ActionListener;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.Socket;
import java.net.UnknownHostException;
import java.awt.event.ActionEvent;
import javax.swing.JTextArea;
import javax.swing.JList;

public class MyClient extends JFrame {

    private JPanel contentPane;
    private Socket socket;
    private DefaultListModel<String> modle;
    private JTextArea textArea;
    private JList list;

    /**
     * Launch the application.
     */
    public static void main(String[] args) {
        EventQueue.invokeLater(new Runnable() {
            public void run() {
                try {
                    MyClient frame = new MyClient();
                    frame.setVisible(true);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }

    /**
     * Create the frame.
     */
    public MyClient() {
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setBounds(100, 100, 450, 558);
        contentPane = new JPanel();
        contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
        setContentPane(contentPane);
        contentPane.setLayout(null);

        JButton btnNewButton = new JButton("发送");
        btnNewButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                write();                                                      //调用write()方法，点击一次按钮就发送一次
            }
        });
        btnNewButton.setBounds(311, 458, 113, 52);
        contentPane.add(btnNewButton);

        textArea= new JTextArea();
        textArea.setBounds(21, 458, 260, 52);
        contentPane.add(textArea);

        list = new JList();
        list.setBounds(21, 44, 260, 386);
        modle=new DefaultListModel<>();
        list.setModel(modle);
        contentPane.add(list);

        JButton btnNewButton_1 = new JButton("连接服务器");
        btnNewButton_1.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                try {
                    System.out.println("客户端启动");
                    socket=new Socket("192.168.0.113", 8080);                 //创建一个流套接字并将其连接到指定 IP 地址的指定端口号
                    Thread myRead=new Thread(new MyClientRead(MyClient.this));//创建新的线程对象，作用是接收发送过来的数据
                    myRead.start();                                           //启动线程
                } catch (UnknownHostException e1) {
                    // TODO Auto-generated catch block
                    e1.printStackTrace();
                } catch (IOException e1) {
                    // TODO Auto-generated catch block
                    e1.printStackTrace();
                }
            }
        });
        btnNewButton_1.setBounds(311, 41, 113, 52);
        contentPane.add(btnNewButton_1);
    }
    public void read(){
        try {
            InputStream is=socket.getInputStream();                         //创建以个输入流
            BufferedReader br=new BufferedReader(new InputStreamReader(is));//创建一个输入缓冲区域
            String line=br.readLine();                                      //读一行文本，放到字符line中
            modle.addElement("服务器说"+line);                              //将line放入modle中即对话列表中
            System.out.println(line);                                       //输出文本line
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    public void write(){
        OutputStream os;
        try {
            os = socket.getOutputStream();                                   //构建一个输出流
            BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(os));//创建一个输出缓冲区域
            String words=textArea.getText();                                 //从输入文本框中得到文本放入words中
            bw.write(words+"\n");                                            //将words写入包中发送
            modle.addElement("客户端说"+words);                                  //将words放入modle中即对话列表中
            textArea.setText("");                                            //清空文字
            bw.flush();                                                      //冲刷
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}
package com.baidu.imSwing;

public class MyClientRead implements Runnable{
    private MyClient client;
     public MyClientRead(MyClient client) {
        this.client=client;
    }
    @Override
    public void run() {
        while(true){
            client.read();
        }

    }

}
package com.baidu.imSwing;

public class MyServerRead implements Runnable{
    private MyServer server;                //创建类型为MyServer的属性
    public MyServerRead(MyServer server) {
        this.server=server;
    }
    @Override
    public void run() {
        while(true){
            server.read();                  //调用read方法
        }

    }

}

ForrestL

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
2015/8/5/抢锁/线程/JFrame

synchronized简单线程线程与JFrame的结合synchronized1.synchronized锁的对象一般为类的对象，不能用太简单的形式例如Integer和boolean，因为过于简单会导致锁错误 2.synchronized的方法锁的对象是：调用该方法的对象 3.为避免抢锁现象的发生，常用Object类中wait和notify方法简单例子package com.baidu.pro
复制链接

扫一扫