Iniciar sesiónCerrar
Correo:
Contraseña:
Entrar
Recordar sesión en este navegador
Iniciar sesiónIniciar sesiónCrear cuentaCrear cuenta
LWP » Foros » Java » uso de Thread

Java - uso de Thread

Volver
Nuevo Tema
<<>>
 
Vista:

uso de Thread

Publicado por Jose Antonio Lopez (1 intervención) el 14/05/2020 04:15:56
Hola, buenas noches.
Tengo un trabajo escolar en el que se pide implementar threads.
La temática es la siguiente: Se tiene un estacionamiento en el que se necesita implementar Thread
Tengo un login que al acceder al sistema me conduce a un menú a partir del cual quiero implementar los Threads.
Al seleccionar el primer botón de alta de usuarios tengo un código que me permite guardar los nuevos usuarios, eso lo quiero meter en un hilo pero no se como hacerlo.
Todo esta en un entorno grafico, el login pasa a un jFrame con el menú y cada botón del menú inicia otro jFrame con diferentes formularios.
Me podrían auxiliar, si es posible con peras y manzanas porque ya no supe como hacerle.
De antemano doy las gracias por la ayuda que me puedan proporcionar

P.D. El código es en Java con NetBeans
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
-1
Responder
Imágen de perfil de Kabuto
Val: 3.428
Oro
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

uso de Thread

Publicado por Kabuto (1381 intervenciones) el 14/05/2020 21:50:34
Ayudaría a que mostrases el código que tengas y/o que des más detalles.
¿Los usuarios se guardan en un array, o en archivo de disco, o en una base de datos? ¿ O da igual?

Más que nada, porque según el diseño de tu código, se puede proponer una cosa u otra.

Por otra parte, no estoy seguro de que aporte nada usar Threads para abrir ventanas de formularios. Puede que para otro tipo de ventanas sí (por ejemplo una ventana que informe en tiempo de real de la temperatura, o que muestre un reloj, etc..)

En cualquier caso, he escrito un ejemplo rápido por si te sirve de algo.

He escrito una clase Cliente básica:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class Cliente {
 
	private String nombre;
	private String apellido;
	private String telefono;
 
	public Cliente() {
		nombre = "";
		apellido="";
		telefono = "";
	}
 
	public Cliente(String nombre, String apellido, String telefono) {
		this.nombre = nombre;
		this.apellido = apellido;
		this.telefono = telefono;
	}
 
	@Override
	public String toString() {
		return String.format("Nombre: %s\nApellido: %s\nTeléfono: %s\n",
				nombre, apellido, telefono);
	}
 
}

Estos Clientes, se almacenan en un ArrayList gestionado por esta otra clase:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class ListaClientes {
 
	private ArrayList<Cliente> clientes;
 
	public ListaClientes() {
		clientes = new ArrayList<Cliente>();
	}
 
	public void addCliente(Cliente c) {
		clientes.add(c);
	}
 
	public String listarClientes() {
		if (clientes.isEmpty())
			return "No hay Clientes registrados";
		else {
			StringBuilder sb = new StringBuilder();
			for (Cliente cli: clientes) {
				sb.append(cli);
				sb.append("\n--------\n");
			}
			return sb.toString();
		}
	}
 
}

Para dar de alta los Clientes se piden datos mediante la siguiente clase, llamada NuevoCliente, que abre un JDialog con los tres campos y un botón Aceptar.
Podría ser un JFrame, pero por convención, al menos hasta donde yo se..., un programa solo debería usar un único JFrame como marco principal. El resto de ventanas deberían ser JDialog (que viene a ser muy similar a un JFrame)

Ojo a esta clase, fíjate que hereda de Thread, y es la que permitirá crear un nuevo hilo.
A parte de construir el JDialgog y tal, tiene un método llamado run() que es el que se activa cuando se inicia este hilo.
Lo único que hace, es mostrar el JDialog que se ha creado mediante el constructor.

Esta clase recibe por parámetros en el constructor una referencia al objeto de la clase que gestiona el ArrayList de Clientes.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
public class NuevoCliente extends Thread {
 
	private ListaClientes lista;
 
	private JDialog dialogoCliente;
	private JTextField campoNombre;
	private JTextField campoApell;
	private JTextField campoTelef;
 
	private JButton btAceptar;
 
	public NuevoCliente(ListaClientes lista) {
		this.lista = lista;
 
		campoNombre = new JTextField(20);
		campoApell = new JTextField(20);
		campoTelef = new JTextField(20);
		btAceptar = new JButton("ACEPTAR");
		btAceptar.addActionListener(new AccionAceptar());
 
		dialogoCliente = new JDialog();
 
		dialogoCliente.setLayout(new BoxLayout(dialogoCliente.getContentPane(), BoxLayout.Y_AXIS));
		dialogoCliente.getContentPane().add(new PanelComponente(campoNombre, "Nombre"));
		dialogoCliente.getContentPane().add(new PanelComponente(campoApell, "Apellido"));
		dialogoCliente.getContentPane().add(new PanelComponente(campoTelef, "Teléfono"));
		JPanel panelBoton = new JPanel();
		panelBoton.add(btAceptar);
		dialogoCliente.getContentPane().add(panelBoton);
 
		dialogoCliente.setTitle("Nuevo Cliente");
		dialogoCliente.setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE);
		dialogoCliente.pack();
		dialogoCliente.setLocationRelativeTo(null);
 
	}
 
	private class PanelComponente extends JPanel {
 
		public PanelComponente(Component c, String titulo) {
			setBorder(BorderFactory.createCompoundBorder(
					BorderFactory.createEmptyBorder(10, 10, 10, 10),
					BorderFactory.createTitledBorder(titulo)));
			add(c);
		}
	}
 
	private class AccionAceptar implements ActionListener {
		@Override
		public void actionPerformed(ActionEvent e) {
			String nombre = campoNombre.getText();
			String apell = campoApell.getText();
			String telef = campoTelef.getText();
 
			lista.addCliente(new Cliente(nombre, apell, telef));
			dialogoCliente.dispose();
		}
	}
 
	@Override
	public void run() {
		dialogoCliente.setVisible(true);
	}
 
}

Bien, por último, la clase principal.
Un JFrame con dos botones, uno para abrir el JDialog de registrar nuevos Clientes y el otro para mostrar los Clientes que se van registrando.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
public class Test extends JFrame{
 
	private JButton btNuevo;
	private JButton btVerCliente;
	private ListaClientes lista;
 
	public Test() {
		lista = new ListaClientes();
 
		btNuevo = new JButton("Nuevo Cliente");
		btNuevo.addActionListener(new AccionNuevoCliente());
		btVerCliente = new JButton("Ver Clientes");
		btVerCliente.addActionListener(new AccionVerCliente());
		JPanel panel1 = new JPanel();
		panel1.setBorder(BorderFactory.createEmptyBorder(100, 100, 100, 50));
		panel1.add(btNuevo);
		JPanel panel2 = new JPanel();
		panel2.setBorder(BorderFactory.createEmptyBorder(100, 50, 100, 100));
		panel2.add(btVerCliente);
 
		getContentPane().setLayout(new FlowLayout());
		add(panel1);
		add(panel2);
 
		setTitle("Test Cliente Thread");
		pack();
		setLocationRelativeTo(null);
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setVisible(true);
	}
 
	private class AccionNuevoCliente implements ActionListener {
		@Override
		public void actionPerformed(ActionEvent e) {
 
			NuevoCliente nuevo = new NuevoCliente(lista);
			nuevo.start(); //Aquí iniciamos un nuevo hilo.
 
		}
	}
 
	private class AccionVerCliente implements ActionListener {
		@Override
		public void actionPerformed(ActionEvent e) {
 
			JOptionPane.showMessageDialog(null, lista.listarClientes(), "Ver Clientes",
					JOptionPane.INFORMATION_MESSAGE);
 
		}
	}
 
	public static void main(String[] args) {
		SwingUtilities.invokeLater(new Runnable() {
			@Override
			public void run() {
				new Test();
			}
		});
	}
 
}


Fíjate sobre todo en la clase interna en la que construyo el ActionListener para el botón que abre el JDialog:

1
2
3
4
5
6
7
8
9
private class AccionNuevoCliente implements ActionListener {
    @Override
    public void actionPerformed(ActionEvent e) {
 
        NuevoCliente nuevo = new NuevoCliente(lista);
        nuevo.start(); //Aquí iniciamos un nuevo hilo.
 
    }
}

Instanciamos un nuevo objeto de la clase NuevoCliente, que es un Thread que construye y muestra el JDialog con el formulario de datos.
Al instancia recibe por parámetros la referencia al objeto que gestiona el ArrayList de Clientes.
Y para iniciar el hilo, invocamos su método .start().
Este método, hace lo que hayamos escrito dentro del método run(), es decir, hacer visible el JDialog.

Y está abierto mediante un hilo separado.

Prueba este código y asegúrate de que lo entiendes. Es muy básico y sencillo.

Intenta aplicarlo en tu programa. Y si no, insisto en que mejor compartas tu código, eso nos ayudaría a guiarte mejor, porque a lo mejor según como sea tu programa hay que pensar en otra forma distinta de implementar hilos.

Un saludo.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar