JaveSe复习（下半）

并发多线程

创建一个线程

public class MyRunnable implements Runnable{ //记得继承接口
    @Override
    public void run() {  //要有run方法
        for (int i = 0; i < 4; i++) {
            System.out.println("子线程输出："+i);
        }
    }
}

        //创建任务对象
        Runnable target = new MyRunnable();
        //任务对象交给线程对象
        new Thread(target).start();

当然也可以这样来创建

public class ThreadTest2_2 {
    public static void main(String[] args) {
        Runnable target = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 4; i++) {
                    System.out.println("子线程" + i);
                }
            }
        };
        new Thread(target).start();

        new Thread(()->{
            for (int i = 0; i < 4; i++) {
                System.out.println("子线程7" + i);
            }
        }).start();
    }
}

第二种创建线程的方法（可以传参）

//让这个类实现callable接口
public class MyCallable implements Callable<String> {
    private final int n;

    public MyCallable(int n) {
        this.n = n;
    }

    //重写call方法
    @Override
    public String call() throws Exception {
        //描述线程的任务，执行返回结果
        int sum = 0;
        for (int i = 0; i < n; i++) {
            sum += i;
        }
        return "线程求出了1-"+n+"的和是"+sum;
    }
}

public class ThreadTest3 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建一个callablle对象
        Callable<String> call = new MyCallable(100);
        //封装成futuretask对象
        //时一个任务对象，实现runnable接口，可以在线程执行完毕之后，调用get接口执行完毕后的结果
        FutureTask<String> f1 = new FutureTask<>(call);
        //把任务对象交给thread对象
        new Thread(f1).start();
        //获取执行完毕返回的结果
        //如果执行到这没有完毕，上面代码会暂停
        String rs = f1.get();
        System.out.println(rs);
    }
}

还有一种方法

public class Mythread extends Thread{
    @Override
    public void run() {
        Thread t = Thread.currentThread();
        for (int i = 0; i < 6; i++) {
            System.out.println(t.getName()+"输出："+i);
            if(i==3){
                try {
                    Thread.sleep(5000); //让程序跑慢一点
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }

    public Mythread(String name) {
        super(name);
    }
}

public class ThreadTest1 {
    //main由默认的主线程负责执行
    public static void main(String[] args) throws InterruptedException {
        //继承thread类
        Thread t1 = new Mythread("一号线程");
        //t1.setName("一号线程");
        t1.start();
        t1.join();
        System.out.println(t1.getName()); //获取线程名字


        Thread t2 = new Mythread("二号线程");
        //t2.setName("二号线程");
        t2.start();
        t2.join();

        System.out.println(t2.getName());

        //启动线程必须调用start方法 而不是run方法
        //不要把主线程任务放在子线程之前

        Thread m = Thread.currentThread(); //哪个线程执行他就会得到哪个线程对象
        m.setName("最秀线程");
        System.out.println(m.getName());
        for (int i = 0; i < 6; i++) {
            System.out.println(m.getName()+"输出："+i);
        }
    }
}

线程安全
第一种：在方法里public和void之间加入synchronized
第二种：在需要线程安全的地方加入synchronized（共享资源）{---}
第三张：创建一个锁对象private final Lock lk = new ReentrantLock();
lk.lock()    lk.unlock()

线程池：new ThreadPoolExecutor
 

//创建线程池
        ExecutorService pool = new ThreadPoolExecutor(3, 5, 8, TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(4), Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());

pool.execute(target)

public class ThreadPoolTest2 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建线程池
        ExecutorService pool = new ThreadPoolExecutor(3, 5, 8, TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(4), Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
        //使用线程池处理callable任务
        Future<String> f1 = pool.submit(new MyCallable(100));
        Future<String> f2 = pool.submit(new MyCallable(200));
        Future<String> f3 = pool.submit(new MyCallable(300));
        Future<String> f4 = pool.submit(new MyCallable(400));

        System.out.println(f1.get());
        System.out.println(f2.get());
        System.out.println(f3.get());
        System.out.println(f4.get());


    }
}

快速创建线程池：ExecutorService pool = Executors.newFixedThreadPool(3);

乐观锁：加入原子类：

public class MyRunnable2 implements Runnable{
    //整数修改的乐观锁 原子类
    private AtomicInteger count = new AtomicInteger();
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("count===>"+count.incrementAndGet());
        }
    }
}

网络编程

UDP通信

public class Server {
    public static void main(String[] args) throws IOException {
        //创建一个服务端对象
        DatagramSocket socket = new DatagramSocket(6666);

        //创建一个数据包对象用于接收数据
        byte[] buffer = new byte[1024 * 64];
        DatagramPacket packet = new DatagramPacket(buffer, buffer.length);

        while (true) {
            //使用数据包接收数据
            socket.receive(packet);
            //打印接收的数据
            //读取多少倒多少
            //获取本次数据包接受多少数据
            int len = packet.getLength();
            String rs = new String(buffer,0,len);
            System.out.println(rs);

            System.out.println(packet.getAddress().getHostAddress());
            System.out.println(packet.getPort());
            System.out.println("------------------------------------");
        }
    }
}

public class Client {
    public static void main(String[] args) throws Exception {
        System.out.println("服务端启动");
        //1创建客户端对象
        DatagramSocket socket = new DatagramSocket();

        //2创建数据包对象封装要发出去的数据
        //参数一封装要发出去的数据
        //参数二发送出去的数据大小（字节个数）
        //参数三服务端的ip地址
        //参数四服务端程序的端口
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请说：");
            String msg = sc.nextLine();

            if ("exit".equals(msg)) {
                System.out.println("欢迎下次光临，退出成功");
                socket.close();
                break;
            }
            byte[] bytes = msg.getBytes();
            DatagramPacket packet = new DatagramPacket(bytes,bytes.length, InetAddress.getLocalHost(),6666);

            //3发送数据
            socket.send(packet);
        }
    }
}

tcp通信

public class Server {
    public static void main(String[] args) throws IOException {
        System.out.println("服务端启动成功");
        //创建serversocket对象，同时为服务端注册端口
        ServerSocket serverSocket = new ServerSocket(8888);

        //使用serversocket对象调用accept方法，等待客户端连接请求
        Socket socket = serverSocket.accept();

        //从socket管道中得到一个字节输入流
        InputStream is = socket.getInputStream();
        DataInputStream dis = new  DataInputStream(is);

        while (true) {
            //使用数据输入流读取客户端发过来的消息
            try {
                String rs = dis.readUTF();
                System.out.println(rs);
            } catch (IOException e) {
                System.out.println(socket.getRemoteSocketAddress()+"离线了");
                socket.close();
                dis.close();
                break;
            }

            //获取客户端的ip地址
            System.out.println(socket.getRemoteSocketAddress());
        }
    }
}

public class Client {
    public static void main(String[] args) throws IOException {
        //创建socket对象 同时请求与服务端程序连接
        Socket socket = new Socket("127.0.0.1",8888);

        //从socket管道中得到字节输出流，用来发送数据给服务端程序
        OutputStream os = socket.getOutputStream();

        //低级流变成数据输出流
        DataOutputStream dos = new DataOutputStream(os);
        Scanner scanner = new Scanner(System.in);
        while (true) {
            //开始写数据出去
            System.out.println("请说：");
            String msg = scanner.nextLine();
            if ("exit".equals(msg)) {
                System.out.println("欢迎下次光临");
                dos.close();
                socket.close();
                break;
            }
            dos.writeUTF(msg);
            dos.flush();
        }
    }
}

 反射

获取类对象：对象.getClass() / 类名.class;
获取全部构造器：c.getDeclaredConstructors();
获取无参构造器：Constructor constructor = c.getConstructor();
想要访问私有构造器要打开开关：constructor.setAccessible(true);
利用反射获取的构造器构造对象：Student student = (Student) constructor.newInstance();
获取有参构造器：Constructor constructor2 = c.getDeclaredConstructor(String.class,int.class);
获取全部成员变量：Field[] fields = c.getDeclaredFields();
获取某个成员变量：Field fName = c.getDeclaredField("name");
取值赋值：先要创建出一个对象才行，fName.set(s,"咖啡毛"); 取值get
获取全部成员方法：Method[] methods = c.getDeclaredMethods();
执行方法：Object rs = run.invoke(s);