Приложение, симулирующее дождевые капли

package Pack;
 
import java.awt.Color;
import java.awt.Dimension;
import javax.swing.JFrame;
import javax.swing.SwingUtilities;
 
public class Runner {
    
    public static void createGUI() {
        JFrame f = new JFrame("Rain");
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.setPreferredSize(new Dimension(500, 500));
        f.setLocation(800, 100);
        f.setBackground(Color.lightGray);
        BackGroundPanel bg = new BackGroundPanel();
        bg.setLayout(null);
        f.add(bg);
        Drop[] drop = new Drop[100];
        for (int i = 0; i < drop.length; i++) {
            drop[i] = new Drop();
            bg.add(drop[i]);
            drop[i].fall();
        }
        
        f.pack();
        f.setVisible(true);
        
    }
        
    
    
    
    
    public static void main(String[] args) {
        System.out.println("Start");
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                createGUI();
            }
        });
            
        }
            
    
    
}
 
 
public class BackGroundPanel extends JPanel {
     public BackGroundPanel() {
         setBackground(Color.lightGray);
    }
 
}
 
 
public class Drop extends JComponent{
    private int x, y, ySpeed;
    
    Drop(){
        x = new Random().nextInt(500);
        y = new Random().nextInt(500);
        ySpeed = new Random().nextInt(5) + 1;
    }
    
    void fall() {
        while(true) {
                y = y + ySpeed;
                if (y == 500) {
                   y = 0;
                  }
                   repaint();
                   try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    
                }
        }
         
    }
    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
         g.setColor(Color.BLUE);
         g.fillRect(10, 10, 10, 30);
     }
      
}

import java.awt.Color;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.geom.Rectangle2D;
import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;
 
import javax.swing.JComponent;
import javax.swing.JFrame;
 
public class Rain {
    public static void main(String[] args) {
        EventQueue.invokeLater(() -> {
            JFrame f = new JFrame();
            f.add(new RainComponent());
            f.pack();
            f.setResizable(false);
            f.setLocationRelativeTo(null);
            f.setVisible(true);
        });
    }
}
 
class RainComponent extends JComponent {
    private static final long serialVersionUID = -6828409152630535756L;
    private static final int COMP_WIDTH = 500;
    private static final int COMP_HEIGHT = 500;
    private static final int DROP_WIDTH = 2;
    private static final int DROP_HEIGHT = 5;
    
    private Rectangle2D[] drops;
    
    public RainComponent() {
        drops = new Rectangle2D[100];
        Random rand = new Random();
        for (int i = 0; i < drops.length; i++) {
            drops[i] = new Rectangle2D.Double(rand.nextInt(COMP_WIDTH), rand.nextInt(COMP_HEIGHT), DROP_WIDTH, DROP_HEIGHT);
            Rectangle2D r = drops[i];
            int speed = rand.nextInt(20);
            Thread t = new Thread(() -> {
                while (true) {
                    int newY = (int) (r.getY() + 1);
                    int newX;
                    if (newY >= COMP_HEIGHT) {
                        newY = 0;
                        newX = ThreadLocalRandom.current().nextInt(COMP_WIDTH);
                    } else
                        newX = (int) r.getX();
                    r.setRect(newX, newY, DROP_WIDTH, DROP_HEIGHT);
                    repaint();
                    try {
                        Thread.sleep(speed >= 10 ? speed : 10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
            t.setDaemon(true);
            t.start();
        }
    }
    
    public void paintComponent(Graphics g) {
        Graphics2D g2 = (Graphics2D) g;
        g2.setColor(Color.BLUE);
        for (Rectangle2D r : drops) {
            g2.fill(r);
        }
    }
    
    public Dimension preferredSize() {
        return new Dimension(COMP_WIDTH, COMP_HEIGHT);
    }
}

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JLayeredPane;
import javax.swing.JPanel;
 
 
public class Rain
{
    public JFrame win;
    public JLayeredPane swap;
    public JLabel[] jl = new JLabel[100];
    public int[] yRain = new int[100];
    
    
    public Rain()
    {
        makeWindow();
        makeRainDrop();
        new WorkerThread();
    }
    
    
    private void makeWindow()
    {
        JPanel panel = new JPanel();
        panel.setPreferredSize(new Dimension(800, 600));
        panel.setOpaque(false);
        
        win = new JFrame("Rain");
        swap = new JLayeredPane();
        swap = win.getLayeredPane();
        win.add(panel);
        win.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        win.setResizable(false);
        win.getContentPane().setBackground(Color.WHITE);
        win.pack();
        win.setLayout(null);
        win.setLocationRelativeTo(null);
        win.setVisible(true);
    }
    
    
    private void makeRainDrop()
    {
        int[] arrRainSize = {30, 30};
        int[] arrRainSpeed = {2, 3, 4, 5};
        //
        BufferedImage bf = new BufferedImage(arrRainSize[0], arrRainSize[1], BufferedImage.TYPE_INT_ARGB);
        Graphics g = bf.createGraphics();
        Graphics2D g2 = (Graphics2D)g;
        g2.setColor(new Color(0,0,0));
        g2.drawLine(arrRainSize[1]/2, 0, arrRainSize[0]/2, arrRainSize[1]);
        g2.dispose();
        //
        for (int i = 0; i < jl.length; i++)
        {
            yRain[i] = new Random().nextInt(600);
            jl[i] = new JLabel();
            jl[i].setBounds(new Random().nextInt(800),
                    yRain[i], arrRainSize[0], arrRainSize[1]);
            jl[i].setName(arrRainSpeed[new Random().nextInt(arrRainSpeed.length)] + "");
            jl[i].setLayout(null);
            jl[i].setOpaque(false);
            jl[i].setIcon(new ImageIcon(bf));
            jl[i].setVisible(true);
            swap.add(jl[i], new Integer(0), i);
            System.out.println(jl[i].getName());
        }
        //
        bf.flush();
    }
    
    
    class WorkerThread extends Thread
    {
        int fps = 15;
 
        
        public WorkerThread()
        {
            setDaemon(true); 
            start();
        }
 
        public void run()
        {
            while (true)
            {
                for (int i = 0; i < jl.length; i++)
                {
                    if (yRain[i] < 600)
                    {
                        yRain[i] += Integer.parseInt(jl[i].getName());
                        jl[i].setLocation(jl[i].getX(), yRain[i]);
                    }
                    else
                    {
                        yRain[i] = 0;
                        jl[i].setLocation(ThreadLocalRandom.current().nextInt(800), yRain[i]);
                    }
                }
                
                try
                {
                    sleep(fps);
                }
                catch (InterruptedException e)
                {
                    //...
                }
            }
        }
    }
    
    
    public static void main(String[] args)
    {
        new Rain();
    }
}

package threadPoolExecutorNumThreads;
 
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
 
 
/**
 *
 * @author vvmu
 */
public class TCachedThreadPool {
     public static int gli = 0;
    public static void main(String[] args) {
        /*создает потоки по мере необходимости, но переиспользует неактивные потоки*/
        ExecutorService service = Executors.newCachedThreadPool();
        
        /*запихиваем наши новые потоки в  наш сервис service.submit десять раз*/
        for (int i = 0; i < 10; i++) {
            service.submit(
 
               new Runnable() {
                @Override
                public void run() {
                    
                    gli++;
                    System.out.println(" gli = " + gli);
                }
            });
        }
        
        // в завершении наших задач нам нужно сделать
        // запрещает добавление новых задач и подготавливает ThreadPoolExecutor к завершению
        service.shutdown();
         try {
            // ожидает завершение ThreadPoolExecutor'a через указанное время
            service.awaitTermination(1, TimeUnit.SECONDS);
        } catch (InterruptedException ex) {
           // Logger.getLogger(ThreadPoolExecutorNumThreads.class.getName()).log(Level.SEVERE, null, ex);
          // логи могут понадобиться для отладки в дальнейшем
        }
        
    }
}

new Runnable() {